Logica de Programacao e Algoritmos Com C Sharp Ed1 PDF

1
Lógica de
Programação e
Algoritmos
com C#
Jackson Camara
Dedico este trabalho a minha amada filha Louise e esposa Daiana por todo amor e carinho. Vocês
deram um sentido especial a minha vida, me proporcionando grandes momentos de alegria.
3
As únicas limitações são aquelas que estabelecemos em nossa mente.
Napoleon Hill.
4
Isenção de Responsabilidade
Este livro é baseado em metodologias praticadas no Curso de Bacharel em Ciência da Computação e
também em livros renomados. Porém algumas abordagens são diferentes de acordo com a visão do
autor desta obra. Essas diferenças são para sintetizar o conteúdo e simplificar o aprendizado, afim de
reduzir anos de estudo para poucos meses.
Não há uma solução mágica que ensine você a programar em poucos dias, se você procura esta
solução, sinto muito, ela não existe. Porém, a metodologia aplicada neste livro, permite que o leitor
aprenda lógica de programação em poucos meses. Desde que, aplique todos os conceitos aprendidos
e faça todos exercícios. Saiba que seu aprendizado depende mais de você, do que qualquer outra
pessoa ou livro. Este livro, foi elaborado para facilitar o seu aprendizado, mas a caminhada será árdua.
Tenho certeza, que ao chegar ao fim desse livro, todo o seu esforço será compensando.
Este livro está na fase de desenvolvimento, não está completo e ainda não foi revisado. A distribuição
desta obra é gratuita, com o intuito de ajudar e receber feedbacks dos nossos leitores. Fique atento em
nosso site, verifique sempre que possível seu e-mail, que em breve teremos mais versões atualizadas.
Caso você queira baixar este e-book atualizado ou assinar a newsletter acesse
www.jacksoncamara.com.br.
5
Para quem é este livro?
Este livro foi elaborado para qualquer pessoa que queira se tornar um desenvolvedor de software. O
conteúdo deste livro apresenta a primeira etapa da programação, o alicerce para construir qualquer
aplicação. Se você deseja entrar no universo da programação de computadores, esta é uma leitura
indispensável.
Assumimos que você não tenha, nenhum conhecimento em algoritmos e lógica de programação ou
qualquer conhecimento avançado em matemática. Você apenas precisa ter vontade e disciplina, que
o resto te guiaremos passo a passo.
Este livro é voltado para o ensino inicial de algoritmos e lógica de programação até o ensino avançado
utilizando a linguagem C#. Procuramos fazer isso de uma maneira bem simples. O livro possui
conceitos teóricos, exemplos práticos e muitos exercícios resolvidos. Acreditamos que os iniciantes
na programação, precisam praticar muitos exercícios de lógica de programação antes de partir para
programação de softwares.
Os ensinamentos desse livro são baseados na grade curricular do Curso de Ciência da Computação,
em livros renomados sobre o assunto e toda a minha experiência adquirida em oito anos como
programador. Matérias do curso de Ciência da Computação como algoritmos, lógica de programação,
estrutura de dados e matemática, estão inseridas nesse livro de forma bem simples, sem pular
nenhuma etapa.
Se você deseja se tornar um programador com habilidades fantásticas em lógica computacional, este
livro lhe aguarda com todo carinho!
6
Fora da curva!
Antes de começar a estudar este livro ou qualquer outra ferramenta que você esteja utilizando para
aprender programação, você precisa entender de uma vez por todas: Você não aprenderá a programar
em poucos dias! Dito isto, deixe toda sua ansiedade de lado, aprenda a controlar, caso contrário, você
será engolido por uma ansiedade devastadora.
Não adianta você ficar 18 horas por dia na frente do computador estudando, seu cérebro precisa de
uma pausa. A melhor pausa para nosso cérebro, não é ficar nas redes sociais ou jogos, mas sim,
praticar exercícios físicos. Se você não pratica nenhum exercício, está na hora de começar. Vá pra
academia, se matricule num curso de arte marcial, natação, etc. Se não tem dinheiro ou tempo para
se deslocar até uma academia, coloque um tênis confortável e vá correr perto da sua casa. Só não
fique parado, sua mente é seu corpo!
Aprender a programar exige uma prática diária, não adianta você ficar dias sem estudar e depois
querer repor esses dias perdidos em um dia. Ser constante é mais importante que ser intenso, a
constância é a chave para aprender a programar. Se você conseguir ser constante e intenso, parabéns,
você se tornará um programador em breve. Defina uma quantidade de horas que você poderá se
dedicar ao estudo por dia, coloque no despertador a hora de começar e a hora de terminar. Já aproveite,
e faça o mesmo para a prática de exercícios físicos.
É comum as pessoas dizerem que não conseguem aprender a programar porque tem déficit de atenção.
Pode ser que realmente tenham, mas provavelmente não passam de um bando de procrastinadores
que preferem usar desculpas esfarrapadas para se sentirem menos mal. Quer ter foco, desligue seu
celular, vá estudar num lugar que tenha silêncio, de preferência o mais longe das pessoas que o
conhece. Se você não tem esse local, aprenda a acordar cedo, que tal as 4:30 da manhã? Se acordar
cedo, durma cedo! A maioria das pessoas precisam de 6 a 9 horas de sono, se você precisa mais do
que isso, algo pode estar errado. Dormir bem é a chave do sucesso.
Quando você acorda cedo, você se sente realizado, você sabe que está na frente da maioria das
pessoas. Por enquanto elas dormem, você já está trabalhando. Provavelmente até o horário do almoço,
você já terá feito todas as suas tarefas. Durante o desenvolvimento do meu TTC (Trabalho Técnico
Cientifico de Conclusão de Curso), eu li um livro que mudou minha vida, O milagre da Manhã de
Hal Elrod. Depois que li esse livro todas as complexidades do meu TTC foram resolvidas antes da
maioria das pessoas acordarem, isso me deixava energizado o dia inteiro.
Se alimentar bem é tão importante quanto praticar exercícios físicos e praticar exercícios físicos é tão
importante quanto estudar. Uma atividade depende da outra, nosso corpo é composto por peças, mas
temos que olhar como uma única peça. Não se esqueça, o seu corpo é sua ferramenta de trabalho. Se
uma coisa vai mal, tudo irá mal, cuide do seu corpo e da sua mente, é nela que você abita. Reduza o
consumo de pizzas, doces, massas, lanches, principalmente tudo que for fast-food e industrializado.
7
Se você possui vícios com drogas, álcool, cigarro está na hora de buscar tratamento. Empresas evitam
contratar pessoas que tenham qualquer tipo de vício, você está reduzindo suas chances de entrar no
mercado de trabalho. Consuma alimentos saudáveis como: aveia, frutas, verduras, sucos, iogurte
natural e beba muita água. Se você não gosta, lamento, em breve você pagará um preço alto.
Programadores adoram tomar café, não exagere, isso atrapalha a qualidade do seu sono, cafeína em
excesso faz mal.
Já ensinei muita coisa que você precisa saber, gostaria que alguém tivesse me ensinado. Mas tive que
aprender com muita luta, o quanto a vida pode ser cruel para aqueles que vivem na ignorância e no
comodismo. A minha liberdade mental veio com a leitura de livros maravilhosos, que me ensinaram
muito. Aprendi que o único culpado sou eu, seja do meu passado, presente ou futuro. Pare de culpar
as pessoas pelo seu fracasso e se vangloriar pelas suas conquistas. Pode ter certeza, você é mais
responsável pelo seu fracasso do que pelo seu sucesso.
Não adianta você querer algo, apenas acreditar que vai conseguir, falando palavras de incentivo, se
você não as coloca em prática. Um versículo da bíblia diz: “Assim também a fé, se não tiver as obras,
é morta em si mesma.” Tiago 2:17. Em suma, esse versículo diz que temos que acreditar e fazer
aquilo que acreditamos, um não vale sem o outro. Em outro versículo: “Bem vês que a fé cooperou
com as suas obras, e que pelas obras a fé foi aperfeiçoada.” Tiago 2:22. Em suma, se você acreditar
e fazer, a sua vontade será aperfeiçoada. Este pensamento gera um ciclo virtuoso, sua fé irá te
manter em pé para que você possa fazer todas obras que você deseja e, suas obras aperfeiçoarão a
sua fé e assim o ciclo continua. Muitos ensinamentos estão na Bíblia gratuitamente, não me importa
se você acredita ou não. Mas você, há de concordar que a bíblia nos ensina muito sobre a vida.
Se você é jovem, parabéns! Você deu um grande passo na sua vida. Se você já não é mais tão jovem
assim, parabéns! Você já ganhou a sua primeira medalha. Apenas por querer mudar de vida, você está
na frente de 99% das pessoas desse país. Se você está se achando velho, porque tem trintas e poucos
anos, quarenta ou cinquenta. Leia o parágrafo abaixo, nele compartilho um dos maiores momentos
da minha vida.
Tenha cuidado com os conselhos que você recebe, principalmente daqueles que nunca construíram
nada. Quando eu tinha meus 26 anos, decidi mudar de vida. Eu sabia que para começar a mudança na
minha vida, eu precisava estudar. Não importa o meio de estudo, faculdade, cursos, livros e etc., eu
apenas sabia que tinha que estudar. Inseguro como era, fui buscar apoio em pessoas próximas a mim,
perguntei a elas: Estou pensando em começar a faculdade de Ciência da Computação, o que vocês
acham? Recebi várias respostas diferentes: “Você já é concursado, tem um bom salário, pra que?”
“Você já está velho, tem que entrar na faculdade igual minha filha fez, aos 17 anos.”, “Vai fazer
faculdade pra ganhar os 10% a mais no trabalho, faz uma qualquer a distância!”, “Cara, não adianta
estudar, nascemos para ser pobre e ferrado.”, “Você sabe que essa faculdade é difícil né?”, “Vai deixar
de ir nos churrascos a noite para ir para faculdade, depois de velho, vai ficar com sua família, vai!”.
Embora eu tenha ouvido péssimos conselhos não fiquei com raiva de ninguém, acredito que nenhum
deles queriam meu mal. Apenas me falaram aquilo que eles tinham dentro deles, a culpa foi minha,
por buscar conselhos no lugar errado.
8
Nesta época eu já estava aprendendo programação sozinho a quase dois anos. Mas, depois de ouvir
todos esses conselhos abomináveis, eu já havia desistido dos meus estudos e da faculdade. Até que
um dia fui levar minha filha no pediatra para uma consulta rotineira. O pediatra dela o Dr. Júlio, além
de pediatra é um excelente psicanalista, com anos de experiência na área. Então perguntei a ele:
“Doutor, estou pensando em começar a faculdade, mas estou velho. O que o senhor acha?”. A resposta
não podia ser mais incrível: “O tempo vai passar de qualquer jeito, você estudando ou não. Daqui 5
anos você pode ser um cientista da computação ou não.
Meu avô aos 81 anos enfartou, e disse ao médico: “doutor eu nunca fumei e bebi, minha alimentação
é saudável, quase não como carne e doces, não tomo café e refrigerante, como isso pode acontecer?
Se eu já tivesse uns 100 anos eu entenderia, me explica? O médico apenas sorriu para meu avô. Em
outra ocasião, poucos dias antes de enfartar, meu avô estava fazendo uma das suas intermináveis
obras, já cansado, me falou: “A se eu tivesse meus 50 anos, eu poderia ...” Ele disse o quanto de coisas
que ele poderia e queria fazer. Você percebeu que ele acha que uma pessoa de cinquenta anos é nova
e que 81 anos é cedo para chegar ao fim da vida. Quero dizer com isso, que tudo depende do ponto
de vista, da perspectiva que você olha o problema, imagino que você entendeu a mensagem.
Infelizmente, só aprendemos a dar valor depois que perdemos. Sem dúvida, se tem algo que não
conseguimos recuperar é o tempo.
Se você chegou até aqui, imagino que está pronto para começar a estudar. Se você acha que não está
pronto ou quer transformar o seu mindset, te aconselho que faça a leitura de dois livros: “O poder da
ação” de Paulo Vieira e o já mencionado “O milagre da manhã” de Hal Elrod. Se após a leitura desses
livros você ainda acha que não está pronto, o universo da programação não é pra você.
Escrevi este livro para você, como se fosse um presente meu, para minha amada filha. Aproveite essa
oportunidade, ninguém fez isso por mim, te entrego esse livro gratuitamente com muito carinho, faça
valer a pena o tempo que dediquei. Os ensinamentos que escrevi nessa seção e todo conhecimento
que compartilharei com você nas próximas páginas, poderão ajudá-lo, para que sua vida seja mais
fácil do que a minha foi. Sei o quanto é difícil não nascer numa família abastada. Se você quer mudar
de vida, embarque nessa jornada, eu estarei aqui para ajudá-lo.
Para finalizar, vou falar um pouco sobre como você deve prosseguir nas próximas páginas. Este livro
utiliza uma abordagem de estudo passo a passo. A dificuldade do livro aumenta a cada nova página
e, cada capítulo depende do anterior. Não é aconselhável o estudo por tópicos, você deve estudar
página por página. Se você quer entrar em contato comigo para tirar alguma dúvida, contar como foi
a sua experiência, sugerir alguma melhoria ou participar de um dos meus cursos acesse
www.jacksoncamara.com.br ou mande um e-mail para jacksonjld@gmail.com.
9
Sobre o Autor
Jackson Camara
é graduado em Ciência da Computação pela Universidade do Vale do Itajaí – UNIVALI. É

proprietário do portal de conteúdo www.jacksoncamara.com.br onde são divulgados cursos e
artigos sobre programação e outros temas relacionados a Ciência da Computação.
Começou sua jornada profissional, trabalhando em gráficas e Agências de Publicidade quando tinha
12 anos. Mas descobriu sua verdadeira paixão no ano de 2012, quando fez seu primeiro site utilizando
a plataforma Magento (se vale dizer isso) com ajuda de muitos plug-ins para criar um e-commerce
para sua esposa. Embora o site tenha funcionado, ocorreram uma série de problemas pela falta de
conhecimento em programação. Desde então, percebeu que o conhecimento em programação seria
necessário para desenvolver um website profissional, que não poderia continuar usando somente
plataformas e plug-ins.
Seus estudos começaram na área de desenvolvimento de websites com as linguagens HTML, CSS,
JavaScript, PHP e MySQL. Após dois anos estudando através de cursos online, começou a faculdade
de Ciência da Computação, aprendendo linguagens como Java, C, C++, muito cálculo e algoritmo. A
faculdade de Ciência da Computação proporcionou-lhe um conhecimento amplo sobre a área, porém,
seu foco sempre foi a programação.
Embora todo aprendizado que a faculdade propicia, não te ensina profundamente as linguagens de
programação e outras tecnologias para o mercado de trabalho. Paralelamente a faculdade se
especializou em Angular, .net Core, C#, Web API, PostgreSQL e AWS. Atualmente, são as principais
ferramentas que utiliza para desenvolver projetos profissionais.
Por saber o quanto é difícil achar conteúdos que ensinam a criar projetos profissionais, sentiu-se
obrigado a compartilhar seus conhecimentos com aqueles que almejam criar aplicações reais. Com
este objetivo resolveu criar o portal www.jacksoncamara.com.br para compartilhar seu
conhecimento. Jackson também é um grande entusiasta em microsserviços, DDD, SaaS, meta-
heurística e apaixonado por fotografia, filha e esposa.
10
Sumário
1 CONCEITOS BÁSICOS ............................................................................................. 15
1.1 Lógica de Programação e Algoritmos ........................................................................ 16
1.2 Pseudocódigo .......................................................................................................... 19
1.3 Linguagens de Programação ..................................................................................... 22
1.4 Editores de Texto e IDEs ........................................................................................... 23
Instalação do Visual Studio Code no Windows............................................................................ 25
Instalação Visual Studio Code no Mac ......................................................................................... 31
1.5 Tipos de fontes ........................................................................................................ 35
Configurando Fontes no VS Code ................................................................................................ 39
1.6 Extensões para Visual Studio Code ........................................................................... 39
Instalando Extensões no Visual Studio Code ............................................................................... 41
Configurando Auto Save no VS Code ........................................................................................... 43
1.7 Net Core Runtime e .Net Core SDK............................................................................ 44
Instalação SDK no Windows......................................................................................................... 46
Instalação SDK no Mac ................................................................................................................. 49
1.8 Terminal .................................................................................................................. 53
Instalando PowerShell Core e Integrando com VS Code no Windows ........................................ 54
Instalando PowerShell Core e Integrando com VS Code no Mac ................................................ 62
Comandos PowerShell, Terminal Linux e macOS ........................................................................ 71
Interface de Linha de Comando (CLI)........................................................................................... 73
1.9 Dispositivos de Entrada/Saída (E/S) .......................................................................... 81
1.10 Alocando espaço na memória, capturando e enviando Dados ao Usuário .................. 83
1.11 Debug ...................................................................................................................... 92
1.12 Unidade Central de Processamento (CPU)................................................................. 95
1.13 Memoria RAM e Memória Cache .............................................................................. 96
2 LINGUAGENS DE PROGRAMAÇÃO ......................................................................... 98
2.1 Introdução ............................................................................................................... 99
2.2 Palavras-chaves ....................................................................................................... 99
2.3 Sensível a Maiúsculo e Minúsculo........................................................................... 104
2.4 Declarações ........................................................................................................... 107
2.5 Espaços em Branco ................................................................................................ 110
2.6 Comentários .......................................................................................................... 112
3 VARIÁVEIS E CONSTANTES .................................................................................. 116
3.1 O que são variáveis ................................................................................................ 117
3.2 Tipos de dados ....................................................................................................... 122
3.3 Char....................................................................................................................... 123
11
ASCII e Unicode .......................................................................................................................... 125
3.4 string ..................................................................................................................... 126
3.5 bool ....................................................................................................................... 128
3.6 Diferença entre tipo numérico inteiro e tipo numérico de ponto flutuante .............. 131
3.7 Tipo numérico inteiro............................................................................................. 132
3.8 Tipo numérico de ponto flutuante .......................................................................... 134
Sufixo de ponto flutuante .......................................................................................................... 138
Precisão de tipos numéricos de ponto flutuante. ..................................................................... 140
3.9 Conversão implícita e explícita. .............................................................................. 142
Conversões entre tipos numéricos ............................................................................................ 142
Conversões entre tipo caractere e tipo numérico ..................................................................... 146
3.10 Constantes............................................................................................................. 150
4 OPERADORES ARITMÉTICOS ................................................................................ 154
4.1 Introdução ............................................................................................................. 155
4.2 Operador de adição ............................................................................................... 155
4.3 Operador de subtração .......................................................................................... 157
4.4 Operação de Multiplicação ..................................................................................... 158
4.5 Operador de divisão ............................................................................................... 159
4.6 Operador módulo .................................................................................................. 160
4.7 Precedência dos operadores................................................................................... 163
4.8 Exercício operações aritméticas e parênteses ......................................................... 167
4.9 Números positivos e negativos ............................................................................... 168
4.10 Exercício média aritmética do aluno ....................................................................... 172
5 Operadores de Atribuição Composta ................................................................... 174
6 OPERADORES RELACIONAIS ................................................................................ 179
6.1 Introdução ............................................................................................................. 180
6.3 Tipos de operandos ................................................................................................ 189
7 Estrutura de Seleção if ........................................................................................ 193
7.1 Instrução if ............................................................................................................ 194
7.2 Exercício controle de entrada de menores no parque .............................................. 197
7.3 Instrução if-else ..................................................................................................... 199
7.4 Instrução if-else aninhada ...................................................................................... 203
7.5 Exercício controle de entrada nos brinquedos do parque ........................................ 207
7.6 Escopo de bloco ..................................................................................................... 209
12
8 ESTRUTURA DE REPETIÇÃO WHILE ...................................................................... 212
8.1 Instrução while ...................................................................................................... 213
8.2 Laços que nunca executam. .................................................................................... 216
8.3 Laços Infinitos ........................................................................................................ 218
8.4 Laços Aninhados .................................................................................................... 220
8.5 Instrução Break ...................................................................................................... 223
8.6 Exercício contador de 0 a 10 com instrução break ................................................... 224
9 OPERADOR LÓGICO............................................................................................. 226
9.1 Operador not (!)..................................................................................................... 227
9.2 Exercício números impares de 0 a 100 .................................................................... 232
9.3 Operador and (&&) ................................................................................................ 234
9.4 Exercício número entre 0 e 100 .............................................................................. 238
9.5 Operador or (||) .................................................................................................... 239
9.7 Precedência dos operadores lógicos ....................................................................... 245
10 OPERADORES DE INCREMENTO E DECREMENTO .............................................. 247
10.1 Introdução ............................................................................................................. 248
10.2 Prefixo e Sufixo ...................................................................................................... 249
10.3 - Operadores de incremento e decremento com laço while. .................................... 251
10.4 Exercício contagem regressiva ................................................................................ 254
11 ESTRUTURA DE REPETIÇÃO FOR ....................................................................... 256
11.1 Introdução ............................................................................................................. 257
11.2 Formato Ascendente e Descendente ...................................................................... 258
11.3 Intervalos diferentes .............................................................................................. 261
11.4 Laços aninhados..................................................................................................... 262
11.5 Escopo de bloco ..................................................................................................... 264
12 ARRAY UNIDIMENSIONAL ................................................................................ 266
13.1 Introdução ............................................................................................................. 267
13.2 Declaração de array ............................................................................................... 268
Instanciando um array ........................................................................................................... 269
Atribuição de valor ................................................................................................................ 271
Sintaxe curta .......................................................................................................................... 272
Tipos de dados ....................................................................................................................... 273
13.3 Atribuição por índice .............................................................................................. 274
13
13.4 Acessando elementos por índice ............................................................................ 276
13.5 Atribuição com laço. .............................................................................................. 277
13.6 Acessando elementos com laço .............................................................................. 278
13.7 Exercício Palavra Inversa ........................................................................................ 280
13.8 Instrução foreach ................................................................................................... 281
13.9 Exercício Lista de Presença ..................................................................................... 284
14 Métodos.......................................................................................................... 287
14.1 Introdução ............................................................................................................. 288
14.2 Como funciona....................................................................................................... 288
14.3 Estrutura ............................................................................................................... 291
14.4 Invocando método ................................................................................................. 292
14.5 Definindo um método ............................................................................................ 295
14.6 Escopo de bloco ..................................................................................................... 297
Inacessíveis por métodos externos ....................................................................................... 297
Variáveis duplicadas no mesmo escopo ................................................................................ 299
Variáveis duplicadas em escopos diferentes......................................................................... 301
Alocação memória ................................................................................................................. 302
14.7 Exercício Vogal ‘a’ .................................................................................................. 304
14.8 Exercício Quantidade de Vogais .............................................................................. 306
14
1 CONCEITOS
BÁSICOS
15
1.1 Lógica de Programação e Algoritmos
Um programa de computador é uma lista de instruções que escrevemos em uma linguagem que o
computador entende. Essa é a frase mais popular para responder o que é um Programa de Computador.
Mas sabemos, que para fazer um programa, não posso escrever “faça um software rápido e bonito pra
mim”. O computador não entende o que falamos. Embora, algumas inteligências artificiais
conseguem entender, não significa que seja possível criar um programa dessa forma.
Todos os programas de computadores são construídos a partir

de instruções individuais, pequenas e específicas que geram um
conjunto de instruções. Por exemplo, uma receita de culinária,
não importa se ela é grande ou pequena, todas receitas possuem
instruções específicas.
Numa receita de bolo de milho, temos várias instruções.

Observe que todas são bem definidas, individuais, pequenas e
específicas. Cada instrução faz apenas uma coisa.
Receita - Bolo de Milho:
• Adicionar 1 lata de milho verde com água e tudo;

• Adicionar 1/2 lata de óleo;
• Adicionar 1 lata de açúcar;
• Adicionar 1/2 lata de fubá;
• Adicionar 4 ovos;
• Adicionar 2 colheres de farinha de trigo;
• Adicionar 2 colheres de coco ralado;
• Adicionar 1 colher e 1/2 de chá de fermento em pó;
• Bater no liquidificador;
• Colocar na forma;
• Levar ao formo aquecido a 180C por 40 minutos.
16
As instruções devem ter etapas e sequência bem definidas.
As etapas são instruções que determinam o que o computador
deve fazer, é uma fase do processo. A sequência é a ordem
em que as etapas são executadas para resolver o problema.
Imagine se você alterar a ordem da instrução “adicionar 4
ovos”, colocando essa instrução por último. Certamente você
não querer este resultado, como na imagem ao lado.
Receita - Bolo de Milho:

• Adicionar 1 lata de milho verde com água e tudo;
• Adicionar 1/2 lata de óleo;
• Adicionar 1 lata de açúcar;
• Adicionar 1/2 lata de fubá;
• Adicionar 2 colheres de farinha de trigo;
• Adicionar 2 colheres de coco ralado;
• Adicionar 1 colher e 1/2 de chá de fermento em pó;
• Bater no liquidificador;
• Colocar na forma;
• Levar ao formo aquecido a 180C por 40 minutos;
• Adicionar 4 ovos.
Este conjunto de instruções é apenas para fazer um

bolo, mas esse bolo poderia fazer parte de um
grande banquete e teríamos vários conjuntos de
instruções diferentes. Na programação e na
culinária, se você quiser resultados
impressionantes e complicados, você ainda usará
instruções simples e básicas.
17
Vamos a um exemplo computacional. Precisamos
construir um módulo de fechamento de conta para os
clientes de um restaurante. Para desenvolver este
módulo é necessário definir as etapas e colocar numa
sequência, conforme apresentado a seguir:
• Somar itens consumidos;
• Calcular taxa de serviço;
• Selecionar forma de pagamento;
• Efetuar Pagamento;
• Calcular troco.
Imagino que você deva estar começando a entender como um software é desenvolvido. Todo esse
processo é feito através de etapas e sequência. Não importa o tamanho e complexidade do código,
você desenvolverá seu código através de pequenas etapas executadas numa sequência.
Etapas são instruções que determinam o que o computador deve fazer, é uma fase do processo. A
sequência é a ordem em que as etapas são executadas para resolver o problema. As etapas e sequência
fazem parte do desenvolvimento do algoritmo.
Um algoritmo é um conjunto das regras e procedimentos lógicos perfeitamente definidos que levam
à solução de um problema, em um número finito de etapas executadas em sequência.
A lógica de Programação é a lógica utilizada para desenvolver um programa de computador. Está

mais relacionado com a forma que se escreve o código.
Poderia dizer que programar e cozinhar é a mesma coisa, mas quando estamos cozinhando, não temos
ctrl + z. Então, acredito que é um pouco diferente. Exercite seu pensamento lógico, faça mais
exercícios como este.
18
1.2 Pseudocódigo
Quando escrevemos passos individuais e informais para serem compreendidos por humanos e não
por computadores, há um nome para isso, pseudocódigo. É uma espécie de tipo de código que
utilizamos quando estamos escrevendo instruções específicas, que ainda não são código fonte. No
exemplo do módulo de fechamento da conta do cliente em um restaurante, usamos pseudocódigo para
definir as etapas e sequências necessárias para desenvolver o módulo.
Módulo - Conta do cliente:

• Somar itens consumidos;
• Calcular taxa de serviço;
• Selecionar forma de pagamento;
• Efetuar Pagamento;
• Calcular troco.
Existem vários benefícios pra isso, por ser uma maneira de se comunicar, pensar e progredir quando
seu cérebro está travado. O pseudocódigo nos ajuda a trabalhar em um problema, sem nos distrair
com a sintaxe da linguagem e outras complexidades ao escrever o código fonte.
Pseudocódigo não é só pra iniciantes, muitas pessoas cometem esse erro.

A simplicidade do código fonte pode ajudar programadores experientes
a resolverem problemas complexos. É comum, programadores
iniciantes pularem esta etapa e, irem direto ao editor de texto, se
deparando com as complexidades da linguagem de programação. Isso é
totalmente compreensível. Porém, o sucesso não é como você escreve
seus códigos e sim como você pensa. O pseudocódigo é uma maneira de
pensar de forma mais rápida.
A melhor maneira de desenvolver um programa, é se

afastar do computador, pegar um lápis e uma folha em
branco. Quando estamos escrevendo no papel não
tentamos escrever o programa todo de uma vez,
fizemos isso por etapas. Essas etapas nos ajudam a
colocar nossos pensamentos em ordem. A grande
vantagem do pseudocódigo é que não há uma sintaxe oficial ou regras rígidas para serem seguidas.
Apenas existe um papel em branco que permite você escrever todo o seu pensamento lógico. Com o
passar do tempo programadores experientes começam a escrever o pseudocódigo de forma muito
parecida com a linguagem de programação favorita.
19
Quando uma equipe se reúne, é comum usar pseudocódigo.
Assim, programadores, designers, representantes, clientes
conseguem entender as instruções que seus colegas estão
escrevendo.
Mesmo que você seja um programador experiente e nunca

tenha feito um jogo. É provável que a primeira vez que for
escrever um jogo, você não saiba como tocar uma música. Se
você tentar executar essas tarefas diretamente num editor de
texto, isso pode ser um problema, que acabaria atrapalhando o
seu pensamento lógico. Ao usar pseudocódigo não ficamos
presos nesses detalhes, fazendo com que nosso pensamento flua com mais naturalidade. Assim
podemos deixar essas características intrínseca da linguagem de programação para uma próxima
etapa.
Para escrever um pseudocódigo corretamente é necessário satisfazer todas as características

fundamentais que todo algoritmo deve cumprir. São características fundamentais:
• Ser preciso: deve indicar a ordem de realização de cada passo;
• Ser definido: se seguir um algoritmo duas vezes, o resultado obtido deve ser o mesmo todas
as vezes;
• Ser finito: se seguir um algoritmo, a ação deve terminar em algum momento, ou seja, deve
ter um número finito de passos.
Um pseudocódigo também pode ser representado por um fluxograma, que pode ser feito com o auxílio
de um software ou apenas com lápis e papel. O fluxograma representado na Figura 1.1, representa
um software de uma fábrica. O fluxograma é executado quando o cliente faz um pedido. Leia-se o
fluxograma da seguinte forma:
• Receber pedido;
• Ler pedido;
• Examinar a ficha do cliente;
• Se o cliente é idôneo a fábrica aceita o pedido, caso contrário, recusa o pedido.
20
Figura 1.1 – Fluxograma fábrica
Embora exista alguns softwares que nos auxiliam na construção de fluxogramas, deixando-o mais
profissional, prefiro lápis e papel.
Pseudocódigo: É uma forma genérica de escrever um algoritmo, utilizando uma linguagem simples
e informal
Código Fonte: O termo código fonte vem do inglês Source Code e define um conjunto de palavras
escritas de forma ordenada contendo instruções em determinada linguagem de programação.
Resumindo, é o algoritmo escrito em linguagem de computador.
21
1.3 Linguagens de Programação
A função do computador é executar os softwares desenvolvidos

pelos programadores. Os programadores não se comunicam
com os computadores através de pseudocódigos, eles se
comunicam através de uma linguagem de programação.
Existem várias linguagens de programação, algumas são usadas

para desenvolver softwares como websites, aplicativos mobile,
servidores, jogos, sistemas embarcados e muitos mais. Algumas
linguagens são extremamente versáteis, podem ser usadas para desenvolver diferentes tipos de
softwares para ambientes diferentes. Por exemplo, a mesma linguagem utilizada para desenvolver um
aplicativo mobile, também pode ser usada para desenvolver um website ou uma Web API.
A linguagem de programação é um método

padronizado utilizado pelos programadores
para expressarem instruções compreensíveis ao
computador. Para ser uma linguagem de
programação é necessário ter algumas
características específicas que permitem
programar um dispositivo, por exemplo, ser
executável.
Linguagens como C#, JavaScript, Python, Ruby,

PHP e Java. São linguagens de programação, porque
permitem que o programador escreva código com
estruturas lógicas que podem ser executadas sem
depender de outra linguagem.
22
Existem outras linguagens
computacionais que parecem
linguagens de programação, mas não
são. Isto acontece, porque são muito
utilizadas pelos programadores, mas
são linguagens que não podem ser
executadas sem a ajuda de outra
linguagem.
A linguagem HTML (inglês HyperText Markup Language - português Linguagem de Marcação de

Hipertexto) é muito utilizada pelos programadores, mas é uma linguagem de marcação de texto e não
de programação. O HTML precisa de uma linguagem como JavaScript para ser executada, isso faz
com que o HTML seja apenas uma linguagem computacional. Linguagens como CSS (inglês
Cascading Style Sheets - português Folhas de Estilo em Cascata) e SQL (inglês Structured Query
Language - português Linguagem de Consulta Estruturada) não são linguagens de programação. A
linguagem CSS é utilizada para estilizar páginas HTML, permite posicionar os elementos, inserir
cores, margens e muito mais. O SQL é uma linguagem usada no banco de dados, exclusivamente para
criar tabelas, manipular os dados das tabelas e consultar os dados.
Embora o HTML, CSS, SQL não sejam linguagens de programação, isso não as torna menos
importante. São linguagens computacionais extremamente poderosas, que fazem parte de diversos
tipos de software.
1.4 Editores de Texto e IDEs

Você não precisa de nenhum software
especial para escrever seus códigos. Quando
falo que não precisa, não estou dizendo que
vamos programar no Word ou no Pages. Não
precisamos formatar nosso texto em itálico
ou negrito etc. Podemos utilizar o Notepad
ou qualquer outro editor de texto simples.
Mas na maioria dos casos é melhor um editor
de texto mais robusto, para facilitar o
desenvolvimento do seu código.
23
Existem editores de textos especiais para programadores que possuem funcionalidades específicas,
como cores para diferentes funcionalidades do código e também ajudam nas correções e escrita do
código. Um editor de texto para programadores, ajuda
a escrever o código, da mesma forma que o Word ajuda
a escrever um texto.
Os editores de texto permitem personalizar tipo e

tamanho de fonte, fundo branco ou preto e diversas
outras configurações para facilitar o uso no dia a dia.
Os desenvolvedores geralmente utilizam fundo preto e
as cores das fontes são a padrão. Alguns editores
costumam ter vários tipos de temas, que é uma
combinação de cores e tamanhos. Mas fique á vontade
para escolher o que mais lhe agrada. Os editores de
texto mais usados pelos programadores são: Visual
Studio Code, Sublime Text, Atom, Brackets.
Além da personalização estética, os editores de texto

ajudam a gerar snippets, que são trechos do código
gerados automaticamente e também ajudam a verificar a sintaxe do código. Observe a Figura 1.2, o
editor está informando ao programador que falta o fechamento de chave (}).
Figura 1.2 - Código erro de sintaxe
Os editores de texto são muito úteis para os programadores e possuem muitas funcionalidades, que
podem ajudar no desenvolvimento de softwares. Mas existe um editor de texto mais robusto que é
chamado de IDE (inglês Integrated Development Enviroment - português Ambiente de
Desenvolvimento Integrado).
24
As IDEs são editores de texto com muitas
funcionalidades, que facilitam a vida dos
programadores. Há pouco tempo atrás, raramente
um programador .Net C#, utilizaria um editor de
texto para desenvolver seus projetos. Esses
programadores costumavam usar apenas a IDE
Visual Studio. Uma IDE extremamente poderosa
e cheia de recursos, principalmente para
programadores de linguagens como C# e C++.
Muitos programadores C# estão utilizando editores de texto como o Visual Studio Code em seus
projetos. Essa escolha ocorre, porque as IDEs consomem muita memória do computador e,
programadores que possuem pouca experiência, podem ter dificuldades em consertar alguns bugs que
acontecem nas IDEs.
Você não deve perder tempo pensando se usa um Editor

de Texto ou uma IDE, se você tem pouca experiência e/ou
um computador menos potente, te aconselho fortemente a
começar por um editor de texto como Visual Studio Code.
Instalação do Visual Studio Code no Windows
Para fazer o download do Visual Studio Code acesse https://code.visualstudio.com/download e

escolha a opção Windows User Installer 64 bit ou 32 bit, de acordo com o seu sistema operacional.
A Figura 1.3 apresenta as opções de download da página do Visual Studio Code.
25
Figura 1.3 - Download VS Code no Windows
Na pasta download clique duas vezes no ícone VSCodeUserSetupx64-1.44.2, conforme apresentado

na Figura 1.4.
Figura 1.4 - Ícone VS Code
A janela apresentada na Figura 1.5, solicita que o usuário selecione a linguagem. Selecione a opção
English e clique no botão OK.
26
Figura 1.5 - Janela de seleção de língua
A janela apresentada na Figura 1.6, solicita que o usuário aceite os termos. Selecione a opção “I
accept the agreement” e clique no botão Next.
Figura 1.6- Janela de aceitação de termos
A janela apresentada na Figura 1.7, informa o local onde o arquivo será salvo. Não altere o local,
apenas clique no botão Next.
27
Figura 1.7- Local de instalação
A janela apresentada na Figura 1.8, informa o local onde o atalho do programa será criado. Clique no
botão Next.
Figura 1.8 - Local do atalho
28
A janela apresentada na Figura 1.9, solicita ao usuário quais tarefas adicionais devem ser realizadas.
Marque as caixas “Create a desktop icon” e “Add to PATH” e clique no botão Next.
Figura 1.9 - Tarefas adicionais
A janela apresentada na Figura 1.10, solicita ao usuário que confirme a instalação. Clique no botão
Install.
29
Figura 1.10 - Solicitação de confirmação de instalação
A janela apresentada na Figura 1.11 informa que o programa foi instalado. Clique no botão Finish.
Figura 1.11- Conclusão de instalação
30
A instalação foi concluída. Para abrir o Visual Studio Code clique no ícone do aplicativo na área de
trabalho ou clique no menu iniciar e procure pelo aplicativo conforme apresentado na Figura 1.12.
Figura 1.12 - Abrindo VS Code.
Instalação Visual Studio Code no Mac
Para fazer o download do Visual Studio Code acesse https://code.visualstudio.com/download e

escolha a opção Mac. Conforme apresentado na Figura 1.13.
31
Figura 1.13 - Download VS Code Mac
Vá até a pasta download e descompacte o arquivo VSCode-darwin-stable.zip. Conforme apresentado

na Figura 1.14.
Figura 1.14- Arquivo de download compactado
32
Arraste o arquivo descompactado Visual Studio Code para dentro da pasta Aplicativos, conforme
apresentado na Figura 1.15.
Figura 1.15 - ícone de instalação e pasta aplicativos
Agora o Visual Studio Code está dentro do diretório aplicativos, conforme apresentado na Figura
1.16
Figura 1.16 - Pasta Aplicativos com VS Code
33
Abra o Launchpad para visualizar os aplicativos. Clique no ícone Launchpad conforme apresentado
na Figura 1.17.
Figura 1.17 - Launchpad
O Visual Studio Code já pode ser visualizado como um aplicativo. Clique duas vezes no ícone do
Visual Studio Code para abrir, conforme apresentado na Figura 1.18.
Figura 1.18 - Launchpad aplicativos.
34
1.5 Tipos de fontes
Podemos utilizar qualquer tipo de fonte no Visual Studio Code, as linguagens de programação não se
importam, mas temos que ficar atento a um detalhe. Em fontes monoespaçada, todos caracteres
ocupam a mesma largura. Já em fontes proporcionais, os caracteres possuem diferentes larguras. As
diferenças entre as fontes são apresentadas na Figura 1.19.
Figura 1.19 - Diferenças entre fontes
A diferença na largura dos caracteres, pode ser um problema para indentar o código. Indentar o código
significa organizar o código, através de espaços em branco na frente de cada linha. Durante o
desenvolvimento, a indentação mantém a estrutura do código, em alguns casos, pode interferir na
execução do programa. Para que não ocorra problemas durante a indentação, deve-se utilizar fontes
monoespaçada. Na seção 2.5 Espaços em Branco é abordado de forma mais detalhada a indentação.
A Figura 1.20 apresenta um código escrito na linguagem C#, indentado com a Fonte Menlo. Observe
que os caracteres, estão um abaixo do outro, ocupando a mesma coluna. Para obter esse resultado
deve-se escolher fontes do tipo monoespaçada.
35
Figura 1.20 - Indentação com fonte Menlo
A Figura 1.21 apresenta um código escrito na linguagem C#, indentado com a Fonte Verdana.
Observe que os caracteres, não estão um abaixo do outro, estão ocupando colunas diferentes. Isto
ocorre ao usar fontes proporcionais. Você pode achar que isso não faz diferença, experimente ficar
várias horas em frente a tela olhando para o código.
36
Figura 1.21 – Indentação com fonte Verdana
A legibilidade da fonte é algo importante. Lembre-se, você terá que escolher uma fonte confortável de
se olhar por um longo período de tempo. Escolher a fonte apropriada, ajudará a distinguir caracteres
semelhantes, por exemplo a letra “l” (L minúsculo) do número “1” (um). Um exemplo é apresentado
na Figura 1.22.
Figura 1.22 - Diferença entre caracteres
Tenha cuidado ao escolher a fonte, não escolha fontes extravagantes, isso deixará seu código confuso.
Na Figura 1.23 é apresentado o código C#, escrito com a letra Impact. Observe como a leitura do
código ficou confusa.
37
Figura 1.23 - Letra Impact.
Procure utilizar fontes Menlo, Monaco, Courier New ou qualquer outra fonte monoespaçada que não
deixe seu código confuso. Figura 1.24 foi utilizada a letra Menlo, observe como a leitura do código
ficou legível.
Figura 1.24 - Letra Menlo
38
Configurando Fontes no VS Code
Para alterar o tipo e tamanho da fonte no Visual Studio Code, clique no ícone Manage localizado na
parte inferior da barra lateral esquerda. Na aba que será aberta ao lado, selecione Text Editor => Font.
Em Font Family digite o nome das fontes que você deseja no seu editor de texto. Só é possível inserir
uma fonte que esteja instalada no seu computador. Siga o exemplo apresentado na Figura 1.25.
Figura 1.25 - Configuração de fonte no VS Code
O VS Code seleciona as fontes pela sequência que foram inseridas, caso a primeira não exista, será
selecionado a segunda e assim sucessivamente. Monospace é um fallback, caso nenhuma das fontes
estejam instaladas no computador, o VS Code buscará uma fonte monoespaçada que esteja instalada.
1.6 Extensões para Visual Studio Code

Os editores de texto podem ficar mais poderosos com o uso de extensões. Algumas extensões
verificam a sintaxe do código, ajudam na formatação do código, alteram o tema, possuem snippets e
muito mais. Você pode verificar uma lista de extensões no marketplace do Visual Studio Code
através do link https://marketplace.visualstudio.com/vscode.
Uma das extensões mais poderosas é o IntelliSense, que inclui inúmeras funcionalidades, como:
ajudar a escrever o código e verificar a sintaxe. Na Figura 1.26, o IntelliSense está informando ao
programador, as opções de código disponíveis para o contexto. O IntelliSense precisa ser instalado
de acordo com a linguagem, cada linguagem possui seu próprio IntelliSense.
39
Figura 1.26 – IntelliSense
A sintaxe se refere a escrita correta do código, de acordo com a linguagem. No exemplo da Figura
1.27, o IntelliSense está informando um erro de sintaxe no código. O erro de sintaxe informa que é
esperado o fechamento de chaves.
Figura 1.27 - IntelliSense erro de sintaxe
As extensões que serão utilizadas durante o desenvolvimento dos exercícios são: C#, Bracket Pair
Colorizer e Material Icon Theme. A extensão C# é o IntelliSense da linguagem. A extensão Bracket
Pair Colorizer altera a cor dos parênteses e chaves do código, facilita a indentação. A extensão
Material Icon Theme altera os ícones dos arquivos, ajuda a diferenciar os tipos de arquivos. Os ícones
são apresentados na Figura 1.28.
40
Figura 1.28 - Ícones das extensões
Instalando Extensões no Visual Studio Code
É possível instalar uma extensão pelo marketplace do VS Code ou diretamente pelo VS Code. Para
fazer a instalação diretamente pelo VS Code, clique no menu Extension que fica localizado na barra
lateral. Um campo de pesquisa e uma lista com várias extensões será apresentada igual a Figura 1.29
Figura 1.29 - Pesquisa de extensões
Digite C# no campo de pesquisa, na aba ao lado e clique no botão verde Install. Siga o exemplo da
Figura 1.30.
41
Figura 1.30 - Instalação do IntelliSense C#
Digite Bracket no campo de pesquisa, na aba ao lado clique no botão verde Install. Siga o exemplo
da Figura 1.31
Figura 1.31 - Instalação do Bracket
Digite Material Icon Theme no campo de pesquisa, na aba ao lado clique no botão verde Install. Siga
o exemplo da Figura 1.32.
Figura 1.32- Instalação do Bracket
Após clicar no botão Install, uma janela será aberta. Selecione a opção Material Icon Theme conforme
42
Figura 1.33 - Configuração Material Icon Theme
Após instalar as três extensões feche o VS Code e abra novamente. As extensões estarão funcionando.
Configurando Auto Save no VS Code
Durante o desenvolvimento do projeto, podemos ativar o Auto Save, para que salve automaticamente
o arquivo que estamos editando. Muitas vezes ficamos concentrado no código e esquecemos de salvar,
caso o computador tenha algum problema e acabe travando, corremos o risco de perder todo o código.
Para ativar o Auto Save no Visual Studio Code, clique no ícone Manage, localizado na parte inferior
da barra lateral esquerda. Na aba que será aberta ao lado, selecione Commonly Used e no campo Auto
Save selecione afterDelay. Siga o exemplo da Figura 1.34.
Figura 1.34 - Configurando auto save
43
Agora você não precisa mais se preocupar em ficar salvando seus projetos. Não se esqueça de fazer
backups do seu arquivo.
1.7 Net Core Runtime e .Net Core SDK

O .Net Core é uma plataforma para desenvolvimento de código aberto de uso geral mantida pela
Microsoft e pela comunidade .Net no GitHub. É multiplataforma e possui alto desempenho para a
criação de softwares modernos. Com o .NET Core é possível criar e executar aplicações com as
linguagens C#, F# e Visual Basic.
Para executar as aplicações desenvolvidas no .Net Core é necessário instalar o .Net Core Runtime.
Para criar aplicações é necessário instalar o .Net Core SDK (inglês Software Development Kit -
português Kit de Desenvolvimento de Software). O SDK possui um conjunto de ferramentas, que
permitem que o programador desenvolva aplicações e bibliotecas para a plataforma .NET
Core. Quando você instala o SDK .Net Core também é instalado a Runtime.
Ao instalar .Net Core é necessários ficar atento as versões disponíveis. A versão que deve ser
escolhida para produção, deve ser a última versão com status LTS (inglês Long Term Support -
português Suporte de longo prazo). Significa que a versão está estável e terá suporte por três anos,
após a versão inicial. Para visualizar as versões .Net Core acesse o link
https://dotnet.microsoft.com/download/dotnet-core. A última versão LTS neste momento é a LTS
conforme apresentado na Figura 1.35.
Figura 1.35 - Status do .Net Core
Todo produto da Microsoft tem um ciclo de vida. O ciclo de vida começa quando um produto é
lançado e termina quando não recebe mais suporte. O fim do suporte refere-se à data em que a
44
Microsoft não fornece mais correções, atualizações ou assistência técnica on-line. O fim do suporte
também pode ser chamado de ‘End of life’ (português - Fim da vida) abreviado 'EOL'.
O conhecimento de datas importantes neste ciclo de vida, ajuda a tomar decisões sobre quando
atualizar o seu software, observe as datas na Figura 1.36. Para saber mais acesse o link
https://dotnet.microsoft.com/platform/support/policy/dotnet-core.
Figura 1.36 - Ciclo de vida
Runtime: é um componente da máquina virtual da plataforma .Net da Microsoft para gerenciar a

execução dos programas.
SDK: é um Kit de Desenvolvimento de Software para plataforma .Net da Microsoft.
Multiplataforma: é um sistema que pode ser executado em mais de uma plataforma. O .Net Core
pode ser executado nos sistemas operacionais Windows, macOS, Linux e também no Docker.
Código aberto: é um modelo de desenvolvimento que promove o licenciamento livre para o design
ou esquematização de um produto e, a redistribuição universal, com a possibilidade de livre consulta,
examinação ou modificação do produto, sem a necessidade de pagar uma licença comercial,
promovendo um modelo colaborativo de produção intelectual. A Microsoft permite criar, modificar,
mesclar, publicar, distribuir, sublicenciar e/ou vender copias do software desenvolvidos com .Net
Core.
F#: é uma linguagem de programação multiparadigma produzida pela Microsoft direcionada a

plataforma .Net. Permite que o foco do programador permaneça no domínio problemático e na
manipulação de dados, em vez dos detalhes da programação.
Visual Basic: é uma linguagem de programação orientada a objetos, produzida pela Microsoft
direcionada a plataforma .Net. Nos dias atuais raramente uma empresa usa esta linguagem para
desenvolver novos projetos, geralmente é usada em aplicações legadas.
45
Instalação SDK no Windows
Digite no seu navegador https://dotnet.microsoft.com/download e selecione a opção Windows no

canto superior. Clique em Download .Net Core SDK para fazer o download, conforme a Figura 1.37.
Figura 1.37 - Instalação do .Net Core
Abra a pasta Downloads e clique duas vezes sobre o ícone dotnet-sdk-3.1.201-win-x64, conforme
Figura 1.38 - Ícone de instalação
Clique no botão Instalar para iniciar a instalação, conforme apresentado na Figura 1.39.
46
Figura 1.39 - Janela de Instalação
A janela informa que o SDK e a Runtime do .Net Core foram instalados com sucesso. Clique em
fechar para concluir a instalação, conforme a Figura 1.40.
Figura 1.40 – Conclusão de instalação
47
Na barra de tarefas no campo de pesquisa digite command e clique em Prompt de Comando, conforme
Figura 1.41 - Prompt de Comando
No Prompt de Comando digite “dotnet - -version” para verificar se o dotnet foi instalado com sucesso.
Compare seu resultado com a Figura 1.42. Dependendo o momento que você estiver instalando o .Net
a versão pode ser diferente. Não se preocupe com isso.
48
Figura 1.42 - Verificação de instalação do SDK pelo Prompt de Comando
Instalação SDK no Mac
Digite no seu navegador o site https://dotnet.microsoft.com/download e selecione a opção macOS no

canto superior. Clique em Download .Net Core SDK para fazer o download, conforme apresentado
na Figura 1.43.
Figura 1.43 - Download .Net Core no macOS
Abra a pasta Downloads e clique duas vezes sobre o arquivo dotnet-sdk-3.1.201-osx-x64.pkg,

conforme apresenta na Figura 1.44.
49
Figura 1.44 - Ícone de instalação
Na janela da Figura 1.45 clique no botão continuar para iniciar a instalação.
Figura 1.45 - Janela de introdução
Na janela da Figura 1.46, o usuário tem a opção de alterar o local da instalação, não altere. Clique no
botão Instalar para manter o local padrão.
50
Figura 1.46 - Local de Instalação
A instalação é iniciada, conforme apresentado na Figura 1.47. Se o Mac pedir a senha de usuário
digite a senha.
Figura 1.47 - Instalação iniciada
51
A janela apresentada na Figura 1.48 informa que a instalação foi concluída corretamente. Clique no
botão fechar.
Figura 1.48 - Conclusão de instalação
A janela apresentada na Figura 1.49, solicita se o usuário deseja manter ou mover o instalador para o
lixo. Clique no botão Mover para o Lixo.
Figura 1.49 - Manter ou excluir arquivo de instalação
52
Para verificar se a instalação ocorreu com sucesso, abra o terminal e digite “dotnet --version”.
Compare seu resultado com a Figura 1.50. Dependendo o momento que você estiver instalando o .Net
a versão pode ser diferente, não se preocupe.
Figura 1.50 - Verificação de instalação do SDK pelo terminal
1.8 Terminal
O terminal é um software que faz a comunicação entre usuário e sistema, enviando comandos e
exibindo a saída para o usuário. Geralmente possui uma tela preta, sem botões e elementos gráficos,
a qual o usuário interage digitando linhas de comando.
Muitos iniciantes acham o terminal sem graça

e/ou assustador. Não se engane, o terminal é
uma ferramenta extremamente poderosa, que
agiliza muito o fluxo de trabalho no dia a dia.
Em muitas situações você vai precisar usar o
terminal para fazer conexões com servidores
externos, criar arquivos via CLI ou até mesmo
para gerenciar seu computador de forma mais
rápida.
53
Alguns desenvolvedores evitam usar o terminal o máximo possível, preferem utilizar as IDEs, por
terem interfaces gráficas que auxiliam no desenvolvimento de suas aplicações. Apesar de ajudarem
muito, nem sempre são intuitivas, em algumas ocasiões, são muito lentas e as vezes geram bugs que
podem ser difíceis de consertar.
Com o terminal temos um resultado mais direto e geralmente mais rápido que a interface gráfica.
Além dessas vantagens, nos possibilita entender melhor como as coisas realmente acontecem. As
interfaces gráficas abstraem muitas coisas, fazendo com que os iniciantes pulem algumas etapas que
deveriam fazer parte do aprendizado.
Quando falamos em terminal, logo imaginamos o Linux. Mas podemos utilizar o terminal no macOS
e no Windows também. A maioria dos comandos do Linux é idêntico ao Mac, já no Windows os
comandos são diferentes. No Windows o terminal é chamado de cmd ou Prompt de Comando.
Outra opção para diferentes sistemas operacionais é o terminal PowerShell Core, que é uma ferramenta
multiplataforma, disponível para Windows, Linux e macOS. O PowerShell utiliza comandos bem
parecidos com o terminal do Linux e macOS.
Instalando PowerShell Core e Integrando com VS Code no

Windows
Durante os exemplos desse curso, será utilizado o terminal PowerShell para não haver diferenças
entre os comandos dos sistemas operacionais Linux, macOS e Windows. A documentação do
PowerShell Core para Windows está disponível no link https://docs.microsoft.com/pt-
br/powershell/scripting/install/installing-powershell-core-on-macos?view=powershell-7.
Para baixar o PowerShell acesse o link https://github.com/PowerShell/PowerShell/releases role a

pagina até assets e clique no link PowerShell-6.2.4-win-x64.msi para fazer o download para sistema
Windows 64 bits.
54
Figura 1.51 - Download PowerShell
Clique duas vezes no arquivo que você fez o download. Clique em Install para iniciar a instalação,
55
Figura 1.52 - Solicitação de instalação do PowerShell
Clique no botão Next para continuar a instalação, conforme apresentado na Figura 1.52.
56
Figura 1.53 - Prosseguir com a instalação PowerShell
O PowerShell será instalado na pasta c:\Program Files\PowerShell\. Mantenha o local padrão, clique
no botão Next conforme apresentado na Figura 1.54.
57
Figura 1.54 - Confirmar local de instalação do PowerShell
Selecione os itens conforme a Figura 1.55 e clique no botão Next.
Figura 1.55 - Seleção de opções adicionais.
58
Clique no botão Finish para terminar a instalação, conforme apresentado na Figura 1.56.
Figura 1.56 - Concluir instalação PowerShell
Abra o VS Code conforme a Figura 1.57 para fazer a integração com o PowerShell.
Figura 1.57 - VS Code Aberto
59
Pressione control + ` para abrir o terminal integrado com o VS Code. Digite no terminal
$psversiontable para visualizar qual versão do PowerShell está sendo usada. Observe no seu terminal
e na Figura 1.58 que a versão utilizada é o PowerShell, mas não é o PowerShell Core. Feche o terminal
clicando no x no lado direito do terminal integrado.
Figura 1.58 - Verificação da versão do PowerShell
Pressione shift + control + p para abrir a janela de comandos do VS Code. Digite Open Settings no
campo e selecione Open Settings (JSON) conforme apresentado na Figura 1.59.
Figura 1.59 - Janela de comando VS Code
Para configurar o terminal integrado do VS Code com o PowerShell. Abra o arquivo settings.json e
insira o texto "terminal.integrated.shell.windows": "c:/Program Files/PowerShell/6/pwsh.exe",
conforme apresentado na Figura 1.60. Observe que estamos definindo o caminho de instalação do
PowerShell.
60
Figura 1.60 - Configuração do arquivo settings.json
Pressione shift + control + p para abrir a janela de comandos. Selecione Reload Window para atualizar
o VS Code conforme a Figura 1.61.
Figura 1.61 - Reiniciando VS Code
Abra o terminal integrado aperte control + `. Digite no terminal $psversiontable para visualizar qual
versão do PowerShell esta sendo utilizada. Compare a Figura 1.62 com o resultado do seu terminal,
observe que agora aparece a palavra Core no lugar de Desktop. Provavelmente a versão será
diferente, não tem problema.
61
Figura 1.62 - Verificação de integração com PowerShell
Instalando PowerShell Core e Integrando com VS Code no Mac
Durante os exemplos desse curso será usado o terminal PowerShell para que não haja diferenças entre
os comandos dos sistemas operacionais Linux, macOS e Windows. A documentação do PowerShell
Core para macOS esta disponível no link https://docs.microsoft.com/pt-
br/powershell/scripting/install/installing-powershell-core-on-macos?view=powershell-7. Para baixar
o PowerShell acesse o link https://github.com/PowerShell/PowerShell/releases role a pagina até o
item assets e clique no link powershell-6.2.4-osx-x64.pkg para fazer o download para o macOS,
Figura 1.63 - Download PowerShell macOS
62
Clique no ícone do arquivo para iniciar a instalação, conforme apresentado na Figura 1.64.
Figura 1.64 - Ícone de download
O macOS não reconhece o programa conforme apresentado na Figura 1.65. Clique em ok.
Figura 1.65 - macOS não reconhece PowerShell
No canto superior esquerdo da área de trabalho clique na maçã e selecione Preferências do Sistema
63
Figura 1.66 - Abrindo preferências do sistema
Em Preferências do Sistema selecione Segurança e Privacidade conforme apresentado na Figura

1.67.
64
Figura 1.67 - Abrindo segurança e privacidade
Clique em Abrir Mesmo Assim conforme apresentado na Figura 1.68.
Figura 1.68 - Concedendo permissão de instalação ao PowerShell
65
A instalação do PowerShell é permitida pelo macOS. Clique em continuar, conforme a Figura 1.69
Figura 1.69 – Introdução da instalação do PowerShell
Clique no botão Instalar para iniciar a instalação, conforme apresentado na Figura 1.70.
Figura 1.70 - Iniciar instalação do PowerShell
66
Digite sua senha e clique em Instalar Software para permitir a instalação conforme a Figura 1.71.
Figura 1.71 - Senha de permissão para instalação do PowerShell
A Figura 1.72 apresenta uma mensagem que a instalação foi realizada com sucesso. Clique no botão
Fechar.
67
Figura 1.72 - Instalação concluída com sucesso
Remova o instalador para o lixo, clique no botão Mover para o Lixo conforme apresentado na Figura
1.73
Figura 1.73 - Mover para o lixo ou manter instalador
68
O PowerShell precisa ser integrado com o VS Code. Observe na Figura 1.74, que o terminal padrão
do Mac está integrado no VS Code. Se o terminal não estiver aparecendo pressione control + `.
Figura 1.74 - Terminal padrão integrado com VS Code
Pressione shift + command + p para abrir a janela de comando do VS Code. Clique em Preferences:
Open Settings (JSON) para abrir o arquivo de settings.json conforme apresentado na Figura 1.75.
Figura 1.75 - Janela de comando VS Code
Para configurar o terminal integrado do VS Code com PowerShell. Insira o texto

"terminal.integrated.shell.osx": "/usr/local/bin/pwsh", "terminal.integrated.shellArgs.osx": [] dentro
do arquivo settings.json conforme a Figura 1.76.
69
Figura 1.76 - Configuração do arquivo setting.json.
Aperte shift + command + p para abrir a janela de comandos. Selecione Reload Window para atualizar
o VS Code, conforme a Figura 1.77.
Figura 1.77 - Atualização do VS Code
Abra o terminal integrado aperte control + `. Digite no terminal $psversiontable para visualizar qual
versão do PowerShell estamos usando. Observe que agora estamos usando o PowerShell Core,
70
Figura 1.78 - Verificação de integração PowerShell e VS Code
Comandos PowerShell, Terminal Linux e macOS
Os comandos a seguir são compatíveis com terminal Linux, macOS e PowerShell. As diferenças
entre os comandos dos terminais são destacadas. Quando uma linha de comando é digitada no
terminal é necessário pressionar o botão enter para executar o comando. Leia e execute os comandos
a seguir:
man
O comando man mostra um manual sobre o uso de um determinado comando. Por exemplo,
digite “man cd” para ler todas as instruções do comando cd. Também existe o comando “man man”,
caso haja dúvidas sobre o uso do próprio man. Se você tiver dúvida sobre algum comando, basta
utilizar o comando “man” seguido do nome do comando. Para sair da tela do manual pressione “q”.
ls
Lista as pastas e arquivos existentes em um diretório. Também é possível usá-lo para conferir o
tamanho e a data de criação de um arquivo ou diretório. Digite “ls” para listar os arquivos e diretórios,
se precisar ver os detalhes digite “ls -lh”.
clear
Limpa o terminal, retirando as letras que foram exibidas no terminal. Digite “clear” para limpar o
terminal.
pwd
Encontra o caminho para o diretório atual. Digite “pwd” para visualizar o caminho do diretório atual.
71
mkdir
Cria um novo diretório (pasta). Digite “mkdir” seguido do nome do diretório, por exemplo “mkdir
pasta1”.
new-item (PowerShell Core)

touch (Linux e Mac)
Cria novos arquivos em branco. Para criar um arquivo digite new-item seguido do nome do arquivo
e extensão. Por exemplo, “new-item site.html”.
cd
Navega pelo sistema de arquivos e permite ir de um diretório para outro. Digite “cd” seguido do nome
do diretório, por exemplo “cd pasta1”. É possível determinar um caminho fazendo o uso de barra, por
exemplo “cd pasta1/pasta2”. Para voltar ao diretório anterior digite cd -. Para voltar um diretório
digite “cd..”.
cp
Permite copiar arquivos e diretórios. Para copiar um arquivo digite “cp” seguido do nome do arquivo
e diretório destino. Por exemplo, considerando que o caminho esteja no diretório pasta1, digite “cp
arquivo1.txt pasta2” para copiar o arquivo arquivo1.txt do diretório pasta1 para o diretório pasta2.
Para copiar um diretório digite “cp -r” seguido do nome do diretório e diretório destino. Por exemplo,
considerando que a pasta2 e a pasta3 estão dentro da pasta1, digite “cp -r pasta3 pasta2” para copiar
a pasta3 para dentro da pasta2. O comando -r permite copiar o diretório com seus arquivos internos.
mv
Move ou renomeia arquivos e pastas. Para renomear um diretório, digite mv seguido do nome da
pasta que você deseja renomear e do novo nome da pasta, por exemplo “mv pasta3 pasta4”, a pasta3
foi renomeado como pasta4. Para renomear um arquivo, insira a extensão do arquivo, por exemplo
digite “mv arquivo1.txt arquivo2.txt”. Para mover o diretório pasta4 para dentro do diretório pasta2,
digite mv pasta4 pasta2. Quando o nome do diretório de destino existe a pasta é movida, se o diretório
não existe é renomeado.
rm
Apaga um arquivo ou diretório. Para apagar um arquivo digite rm seguido do nome do arquivo, por
exemplo “rm arquivo2.txt”. Para apagar um diretório e o conteúdo digite rm -r seguido do nome do
diretório, por exemplo “rm -r pasta4”.
more
Mostra o conteúdo de um arquivo texto. Para ler o conteúdo de um arquivo digite more seguido do
nome do arquivo, por exemplo digite “more arquivo1.txt”.
sudo
Determinados comandos ou arquivos são acessíveis apenas pelo usuário administrador (root). Este é
um superusuário que possui privilégios de leitura e gravação em mais áreas do sistema, inclusive arquivos
72
em outras contas de usuários. Para que você não tenha que trocar de usuário a todo instante, existe o
comando sudo, que garante credenciais de usuário root temporariamente, mediante a informação de
uma senha. É mais seguro usar o comando sudo no terminal em vez de ativar o usuário raiz. Apenas utilize
este comando se souber o que está fazendo, caso contrário poderá danificar o sistema operacional.
select-string (PowerShell Core)

grep (Linux e Mac)
Ajuda a procurar uma determinada palavra em um arquivo. Para procurar uma palavra num arquivo
digite select-string seguida da palavra a ser pesquisada e o nome do arquivo. Por exemplo, “select-
string desenvolvedor arquivo1.txt” será apresentado a linha que contém a palavra pesquisada. O
comando select-string não diferencia maiúsculos e minúsculo.
history
Apresenta o histórico dos comandos utilizados. Digite “history” e uma lista com todos comandos
utilizados por você será apresentada.
Interface de Linha de Comando (CLI)
Para desenvolver aplicações em .Net Core usando o VS Code, é necessário usar a CLI (Interface de
Linha de Comando) do .NET Core. A CLI é uma ferramenta multiplataforma para criação,
desenvolvimento, execução e publicação de aplicativos .NET Core. Não é necessário fazer a
instalação da CLI do .NET Core porque já está incluído no .NET Core SDK.
Para executar qualquer ação com a CLI, devemos

inserir os comandos diretamente no terminal do
sistema operacional. A CLI .Net Core, entende
que estamos digitando um comando, através do
driver “dotnet”. O driver é responsável por
executar um aplicativo ou executar um comando
.Net Core.
A estrutura de comando CLI consiste no driver, seguida pelo comando e possivelmente de templates,
opções e argumentos de comando. Para acessar uma breve documentação de ajuda dos comandos
dotnet, digite “dotnet help”, conforme apresentado na Figura 1.79. A lista completa de comandos,
pode ser acessada na documentação oficial do .Net Core https://docs.microsoft.com/pt-
br/dotnet/core/tools/dotnet?tabs=netcore21 .
73
Figura 1.79 - Comando dotnet help apresenta lista de comandos
Cada comando define seus próprios argumentos, para acessar uma breve documentação de ajuda,
digite “--help” após o comando. Por exemplo, para acessar a documentação de ajuda do comando
“new”, digite “dotnet new --help” conforme apresentado na Figura 1.80. Além das opções é
apresentado uma lista de templates.
74
Figura 1.80 - Lista de templates e opções do comando new
Os templates são os tipos de arquivos que podem ser criados, é possível criar arquivos do tipo
Console, Web API, MVC e vários outros. As opções passadas na linha de comando são referentes ao
comando invocado. Quando você cria um arquivo, você vai querer dar um nome. Para isso, é chamada
a opção “--name” seguida do argumento que é o nome que você pretende dar ao projeto.
75
Para criar um projeto do tipo console com o nome “MeuApp”, é necessário digitar no terminal o
comando “dotnet new console --name MeuApp”. Onde “dotnet” é o drive, “new” é o comando,
“console” é o template, “--name” é a opção para nomear o projeto e “MeuApp” é o nome do projeto
sendo o argumento da opção --name”. Observe o exemplo da Figura 1.81.
Figura 1.81 - Comandos dotnet
Exemplo prático
No PowerShell Core navegue pelo terminal com o comando cd até o diretório desktop para criar um
programa .Net Core. Digite no terminal o comando “dotnet new console --name MeuApp”. Siga o
exemplo da Figura 1.82.
76
Figura 1.82 - Criando programa do tipo console .Net Core
A pasta MeuApp com os arquivos do programa é criada na área de trabalho, conforme apresentada
na Figura 1.83.
Figura 1.83 - Arquivo criado na área de trabalho
Clique no ícone Explorer na barra lateral esquerda e no botão Open Folder conforme apresentado na
Figura 1.84.
77
Figura 1.84 - Abrindo o programa MeuApp
Selecione a pasta MeuApp e clique em Abrir conforme a Figura 1.85.
Figura 1.85 - Localizando pasta do programa MeuApp
No canto inferior direito do VS Code uma janela é aberta, perguntando se você deseja adicionar os
arquivos de Construção e Debug. Clique no botão Yes para adicionar os arquivos.
78
Abra o terminal integrado. Vá até o menu superior e clique em Terminal => New Terminal, conforme
Figura 1.86 - Abrindo terminal integrado VS Code
Digite no terminal integrado o comando “dotnet run” conforme apresentado na Figura 1.87. Se no
terminal aparecer a palavra “Hello World!”, você acaba de criar o seu primeiro programa. Parabéns!!!
79
Figura 1.87 - Executando o programa
80
1.9 Dispositivos de Entrada/Saída (E/S)
Os dispositivos de Entrada/Saída (E/S) (inglês, Input/Output, I/O) ou periféricos, permitem a
comunicação entre usuário e computador. Essa comunicação é feita através de instruções e dados que
são transmitidos entre os dispositivos. Os dados são introduzidos no computador pelos dispositivos
de entrada, em seguida, o computador processa esses dados para produzir uma saída.
Os dispositivos de entrada servem para introduzir dados no computador, para que possam ser
processados. Os dispositivos mais comuns são: teclado, mouse, microfone, webcam, scanner e outros,
Figura 1.88 - Dispositivos de entrada
Os dispositivos de saída permitem representar os resultados do processamento dos dados. Os

dispositivos de saída mais comuns são: monitor, impressora, caixa de som, fone de ouvido, projetor
e outros, conforme apresentado na Figura 1.89.
81
Figura 1.89 - Dispositivos de saída
Alguns dispositivos, fazem a função de entrada e também a de saída, são chamados de dispositivos
híbridos. Os dispositivos híbridos mais comuns são: pendrive, HD externo, impressora
multifuncional, monitor touch screen, modem e outros, conforme apresenta na Figura 1.90.
Figura 1.90 - Dispositivos híbridos
82
Os dispositivos de entrada e saída, permitem criar softwares, que capturaram os dados inseridos pelo
usuário para serem processados e posteriormente retornados ao usuário. Um exemplo é apresentado
na Figura 1.91.
Figura 1.91 - Comunicação dos dispositivos com o software
1.10 Alocando espaço na memória, capturando e enviando

Dados ao Usuário
Quando recebemos um dado do usuário, muitas vezes precisamos armazena-lo para processa-lo
posteriormente. Esse armazenamento é feito através de alocações de espaços na memória. A forma
mais simples de alocar um espaço na memória é através de variáveis. Para definir uma variável, digite
no programa a palavra-chave var acompanhada de um nome, que serve como um identificador.
Através do nome da variável, é possível chama-la quando for necessário. A declaração da variável é
apresentada na Figura 1.92.
83
Figura 1.92 - Alocação de espaço na memória
Durante os exercícios, será usado o terminal PowerShell para capturar os dados do usuário nas
aplicações desenvolvidas e também para enviar os dados processados ao usuário. O C# possui alguns
comandos para se comunicar com o usuário através do terminal:
• Console.ReadLine();
Captura uma entrada de texto inserida pelo usuário no terminal.
• Console.WriteLine();
Apresenta uma saída de texto ao usuário no terminal, fornece uma nova linha no fim do texto.
• Console.Write();
Apresenta uma saída de texto ao usuário no terminal, mas não fornece uma nova linha.
Podemos capturar um dado inserido pelo usuário e armazenar numa variável através da instrução
“Console.ReadLine()”. O operador de atribuição simples, é representado pelo símbolo “=” (sinal de
igual). Este operador, atribui o valor da expressão a direita para a variável situada a esquerda,
84
Figura 1.93 - Capturando dado do usuário e armazenando
Um dado pode ser enviado ao usuário, através da instrução “Console.WriteLine()”, conforme

apresentado na Figura 1.94. A variável é invocada pelo nome e o conteúdo armazenado é apresentado
no terminal.
Figura 1.94 - Enviando dado ao usuário
Exemplo prático
Abra o VS Code e o terminal integrado PowerShell. Crie um projeto do tipo console, digite no
terminal o comando “dotnet new console -n CapturaEnviaDadosUsuario” e pressione enter.
85
Figura 1.95 - Criando projeto do tipo console através do terminal
Clique em Open Folder, localize o projeto e abra no VS Code, conforme a Figura 1.96.
Figura 1.96 - Abrindo projeto
O VS Code abre uma janela no canto inferior direito informando que os recursos necessários para
construir e debugar o projeto estão ausentes. Clique em sim para criar os arquivos necessários,
86
Figura 1.97 - Criando arquivos de compilação e debug.
Abra o arquivo Program.cs e apague a linha 9 conforme a Figura 1.98.
Figura 1.98 - Apagando linha 9 do projeto
Digite a instrução “Console.Write(“Digite seu nome: ”);” . O texto a ser mostrado para o usuário deve
ser escrito entre parênteses e aspas dupla. Observe o exemplo da Figura 1.99.
87
Figura 1.99 – Instrução para mostrar texto ao usuário
Na linha de baixo da instrução anterior, digite “Console.ReadLine();” para capturar o texto inserido
pelo usuário. Um exemplo é apresentado na Figura 1.100.
Figura 1.100 - Instrução para capturar texto
No terminal digite o comando “dotnet run” para executar o projeto. Observe que o texto “Digite seu
nome:” está aparecendo no terminal. Isso significa que a instrução “Console.Write(“Digite seu nome:
”);” foi executada com sucesso. A instrução “Console.ReadLine()” também foi executada e está
aguardando o usuário inserir o nome no terminal. Um exemplo é apresentado na Figura 1.101.
88
Figura 1.101 - Projeto em execução
Insira seu nome e pressione enter para encerrar a execução do sistema, conforme apresentado na
Figura 1.102.
Figura 1.102 - Interação com o programa
89
O dado que estamos capturando através da instrução “Console.ReadLine()” não está sendo
armazenado em nenhum local da aplicação. Para armazenar os dados, precisamos alocar um espaço
na memória do computador. Declare a palavra chave “var”, seguida do nome que queremos dar para
esse espaço da memória. O nome do espaço da memória, deve fazer sentido, considerando que
estamos perguntando o nome do usuário, vamos nomear esse espaço na memória de “nomeUsuario”.
Siga o exemplo da Figura 1.103.
Figura 1.103 - Armazenando dados capturados
Digite a instrução “Console.WriteLine($“Seu nome é: {nome}”);”. Quando utilizamos o sinal “$”

estamos dizendo ao compilador que haverá uma concatenação dentro de aspas dupla. A concatenação
é a junção de texto com variável. Para informar o compilador que uma palavra é uma variável e não
um texto, insira a palavra entre chaves. Siga o exemplo da Figura 1.104.
90
Figura 1.104 - Concatenando variável e texto
Digite “dotnet run” no terminal, o programa irá pedir seu nome. Digite seu nome e pressione enter
para o programa processar os seus dados. O programa mostrará o seu nome novamente conforme
Figura 1.105 - Executando programa
91
1.11 Debug
A prática de debugar é muito usada por programadores, analistas de sistemas e demais profissionais
de T.I.. Pode ser usada em uma situação em que precisamos analisar um determinado trecho do
programa ou para localizar possíveis bugs (erros) de programação no sistema.
Para fazer o debug de um programa no VS Code é muito simples. Abra o programa da seção anterior
“CapturaEnviaDadosUsuario”. Durante o debug o terminal fica bloqueado, para que possamos
utilizar o terminal, precisamos configurar o arquivo launch.json localizado dentro da pasta .vscode.
Dentro do arquivo na propriedade “console” apague o valor “internalConsole” e insira
“integratedTerminal” entre aspas duplas. Siga o exemplo destacado na Figura 1.106.
Figura 1.106 - Configurando terminal para debugar.
Agora que o terminal está devidamente configurado para o debug, vamos fazer o debug. Abra o
arquivo program.cs e insira um breakpoint (ponto de parada) na linha 9. Para inserir o breakpoint
coloque o cursor do mouse um pouco á esquerda do numeral de identificação da linha, observe que
um ponto vermelho aparecerá, de um clique e o ponto ficará fixo. Na barra lateral esquerda de menu,
clique em Run. Clique na seta verde no canto superior esquerdo, para iniciar o debug. Observe na
Figura 1.107 que a execução do programa iniciou e parou na linha 9, onde está localizado o
breakpoint.
92
Figura 1.107 - Iniciando Debug.
O programa precisa receber uma ordem para avançar para próxima instrução, clique no botão “step
into”. Siga os passos da Figura 1.108 e observe que a frase “Digite seu nome: ” esta aparecendo no
terminal.
Figura 1.108 – Avançando uma instrução durante debug
Durante o debug é apresentado um painel do lado esquerdo, dentro desse painel são apresentadas as
variáveis do programa. Observe na Figura 1.109 que a variável nome que declaramos se encontra
nesse painel, com o respectivo valor ao lado. A variável nome possui valor null, isso significa que
nada foi atribuído, está vazia.
93
Figura 1.109 - Painel de debug mostra variáveis.
Precisamos atribuir um valor a variável, clique novamente sobre o botão “step into”. Escreva seu
nome no terminal e aperte enter. Observe na Figura 1.110 que a variável nome foi preenchida com
meu nome.
Figura 1.110 - Analisando variáveis durante debug
Clique mais uma vez no botão “step into”. Observe na Figura 1.111 que a instrução da linha 11 foi
executada e apresenta a frase “Seu nome é: Jackson” no terminal. Clique mais uma vez no botão “step
into” para que o programa chegue no final das instruções e seja encerrado.
94
Figura 1.111 – Finalizando debug
1.12 Unidade Central de Processamento (CPU)

Quando pensamos em processamento computacional, achamos que o responsável por processar todos
os dados é o computador. Na verdade, quem de fato processa os dados é um único hardware, a
Unidade Central de Processamento (CPU - Central Process Unit), também chamada de processador.
A CPU processa os dados, as instruções dos programas e todo sistema operacional.
A CPU controla as atividades do computador, determina quais operações devem ser realizadas,
colocando em ordem e sincronizando todo o processamento do computador. A CPU também processa
todas operações aritméticas e lógicas, tais como adição, subtração, multiplicação, divisão e
comparações que são cruciais para fazer as tomadas de decisões dos programas.
Um erro comum, é chamar o gabinete de CPU. O gabinete é uma estrutura física para armazenar as
peças do computador, por exemplo: HD, CPU, memória RAM, interfaces e placa mãe. Observe as
diferenças entre CPU e Gabinete na Figura 1.112.
95
Figura 1.112 - Diferença entre CPU e gabinete
A CPU está presente em

computadores, notebooks, celulares,
tablets, video games e em todos
dispositivos que precisam fazer
qualquer tipo de processamento
computacional.
A CPU lê e processa as instruções ou dados que

estão armazenados na memória RAM e depois
de processar esses dados, pode armazenar
novos dados na memória RAM.
1.13 Memoria RAM e Memória Cache
A memória RAM (inglês Random Access Memory - português Memória de Acesso Aleatório) é
utilizada para armazenar informações. A memória RAM armazena as informações dentro de células
que são pequenos compartimentos, que podem armazenar informações como:
• Os dados enviados dos dispositivos de entrada para o processamento;

• Os programas que estão em execução (Sistema Operacional, Photoshop, seu programa);
• Os dados que estão sendo processados pelos programas;
• Os resultados obtidos para serem enviados a um dispositivo de saída;
96
As células possuem um tamanho finito pra
armazenar os dados, e possuem um endereço
único para que possam ser localizadas. Quando
a CPU precisa de algum dado, busca na
memória RAM e armazena na memória cache.
A memória cache serve como um armazenamento intermediário de dados

entre o processador e a memória RAM, tornando a execução do processador
mais rápida. Geralmente a memória cache já vem incorporada no próprio
processador.
Após processar os dados a CPU pode manipular os dados que estão na memória RAM. Por exemplo,
gravar um novo dado para ser usado posteriormente ou para enviar a um dispositivo de saída. A
principal função da memória RAM é entregar os dados de forma rápida para CPU. Observe um
exemplo de comunicação entre Memória RAM e CPU na Figura 1.113.
Figura 1.113 - Comunicação entre Memória RAM e CPU
97
2 LINGUAGENS
DE
PROGRAMAÇÃO
98
2.1 Introdução
Neste capítulo teremos uma visão geral sobre as linguagens de programação, você não deve se
preocupar com os detalhes de cada linguagem. Apenas tente entender os princípios fundamentais que
estão inseridos nas linguagens de programação.
Toda linguagem de programação possui um conjunto de regras, que determinam como você escreve
o código. As regras das palavras regem: significado, ordem, maiúsculos ou minúsculos, etc. As regras
são a sintaxe da linguagem de programação, devem ser cumpridas.
A sintaxe deve ser respeitada para que o compilador ou interpretador possa ler as instruções do código
fonte. Por exemplo, em C# a regra maiúsculo e minúsculo, exige que a palavra “true” seja escrita em
minúsculo, se a primeira letra for maiúscula, o compilador não conseguirá entender o significado da
palavra e um erro será gerado.
Os cinco princípios fundamentais que definem as regras das linguagens são: Palavras-chave (inglês -
keywords), Declarações (inglês - statements), Sensível a Maiúsculo e Minúsculo (inglês - case-
sensitive), Espaços em branco (inglês - whitespace) e comentários (inglês - comments).
2.2 Palavras-chaves
Uma palavra-chave é uma palavra que quando escrita no código-fonte, a própria linguagem de
programação sabe o significado daquela palavra. Você não precisa dizer o que a palavra significa,
porque a palavra tem um significado especial para linguagem. Devemos usar, apenas quando
queremos que cumpra algum propósito específico da linguagem.
Muitas palavras chaves são comuns em

diferentes linguagens de programação. Por
exemplo, a palavra “if” existe na linguagem C#,
JavaScript, Java, Python, C++ e várias outras
linguagens.
Uma linguagem como C#, possui 76 palavras-chaves e mais 28 palavras-chaves contextuais. As

palavras-chaves são palavra-chave em qualquer lugar do programa, não importa aonde estão inseridas
ou como estão sendo utilizadas. As palavras-chaves contextuais, dependem do local que estão
inseridas e como estão sendo utilizadas para serem palavra-chave. A Tabela 2-1 apresenta as palavras-
chaves e a Tabela 2-2 apresenta as palavras-chaves contextuais da linguagem C#.
99
abstract as base bool
break byte case catch
char checked class const
continue decimal default delegate
do double else enum
event explicit extern false
finally fixed float for
foreach goto if implicit
in int interface internal
is lock long namespace
new null object operator
out override params private
protected public readonly ref
return sbyte sealed short
sizeof stackalloc static string
struct switch this throw
true try typeof uint
ulong unchecked unsafe ushort
using using static virtual void
Tabela 2-1- Palavras-chaves.
add alias ascending
async await by
100
descending dynamic equals
from get global
group into join
let nameof on
orderby parcial (tipo) partial (método)
remove select set
não gerenciado (restrição de tipo

value var
genérico)
where (restrição de tipo where (cláusula de

when (condição de filtro)
genérico) consulta)
yield
Tabela 2-2 - Palavras-chaves contextuais.
Exemplo prático
Digite no terminal o comando “dotnet new console -n PalavraChave” para criar um programa. Abra
o programa no VS Code e copie o código da Figura 2.1. Observe que foi alocado um espaço na
memória com o nome cidade. A palavra cidade não é uma palavra-chave, portanto, nenhum problema
ocorreu.
101
Figura 2.1 – Nome de variável sem ser palavra-chave.
Ao tentar alocar um espaço na memória com a palavra-chave “true”, o IntelliSense aponta um erro.
A mensagem de erro, informa que “O lado esquerdo de uma atribuição deve ser uma variável,
propriedade ou indexador”. Observe que a mensagem, não informa que “true” é uma palavra-chave,
porque subentendesse que o programador saiba. Copie o código da Figura 2.2, deixe o mouse sobre
o sublinhado vermelho da linha 9 para visualizar o mesmo erro.
Figura 2.2 - Locação de memória com palavra-chave
Copie o código da Figura 2.2 e execute o programa. Após executar a aplicação, o terminal mostra o
nome da propriedade cidade e não o conteúdo Itajaí, isso significa que “nameof” foi utilizado como
palavra-chave.
102
Figura 2.3 – Uso da palavra-chave contextual nameof
Copie o código da Figura 2.4 e execute o programa, observe que o erro “Não é possível usar a variável
local 'nameof' antes de ser declarada” é apresentado no terminal. A palavra-chave contextual
“nameof” se utilizada como nome de variável, faz com que o compilador trate “nameof” como
variável e não como palavra-chave.
Figura 2.4 - Alocação de memória com palavra-chave contextual com erro
103
Copie o código da Figura 2.5 e execute o programa. A palavra-chave contextual é utilizada apenas
como variável, o programa é executado com sucesso.
Figura 2.5 - Alocação de memória com palavra-chave contextual sem erro
Mesmo que seja permitido usar palavras-chaves contextuais para nomear outras propriedades,
devemos evitar. Assim, reduzimos as possibilidades de conflito em nosso código.
Cada linguagem possui uma quantidade de palavras-chaves, mas isso não é importante. Muito menos
você deve se preocupar em decorar todas essas palavras. Com o tempo você irá adquirir experiência
e seu vocabulário de palavras chaves e combinações aumentará cada vez mais.
2.3 Sensível a Maiúsculo e Minúsculo
Linguagens mais antigas como algumas versões do Basic ou Pascal são case-insensitive, não se
importam se você escreve as palavras com maiúsculo ou minúsculo. No entanto, a maioria das
linguagens modernas são case-sensitive, se importam se você usa maiúsculo ou minúsculo e são
extremamente exigentes em relação a isso.
Quando escrevemos uma frase, algumas palavras devem ser em maiúsculo outras em minúsculo,
assim é na linguagem de programação. As diferenças que você encontra no mundo real, você também
encontrará nas linguagens de programação.
104
Essas diferenças entre as linguagens, geralmente não tem motivo, foi apenas feito daquele jeito.
Observe a frase escrita em inglês na Figura 2.6. Na língua inglesa a palavra “I” (Eu) escrita no meio
da frase, se escreve em maiúsculo e “you” (você) se escreve em minúsculo. Por que essa diferença?
Não sei, apenas faço assim. E assim deve ser na programação, a não ser que você queira estudar toda
a história para tentar chegar a uma conclusão, se é que existe.
Figura 2.6 - Maiúsculo e minúsculo.
A linguagem Python exige que a palavra-

chave “True” seja escrita com a primeira
letra em maiúsculo e o restante em
minúsculo. No Swift a palavra-chave
“true” é toda em minúsculo. Na linguagem
C# a palavra “true” deve ser escrita toda
em minúsculo.
Exemplo prático
Digite o comando “dotnet new console -n SensivelMaiusculoMinusculo” no terminal para criar um

programa. Abra o programa no VS Code, copie o código da Error! Reference source not found. e
execute o programa. Observe que palavra-chave “true” foi escrita como “True”, com a primeira letra
em maiúsculo. A linguagem C# não reconhece a palavra, porque deveria ter sido escrita toda em
minúsculo.
105
Figura 2.7 - Palavra-chave case-sensitive errado
Ao corrigir a palavra “True” para “true” o código é executado normalmente, conforme apresentado
na Figura 2.8.
106
Figura 2.8 - Palavra-chave case-sensitive correto
2.4 Declarações
Em uma declaração não perguntamos nada ao computador, apenas dizemos o que tem que ser feito.
Quando escrevemos uma instrução ao computador, estamos fazendo uma declaração. As declarações
podem ser variáveis, constantes, métodos, delegates, eventos, propriedades ou campos. Para informar
o fim da declaração na maioria das linguagens, devemos inserir um ponto e vírgula ou uma quebra
de linha.
Linguagens como C, C++, PHP, Java e C#, é necessário colocar um ponto e vírgula no fim da
declaração, para que o compilador ou interpretador, entenda que a declaração terminou. Outras
linguagens como Swift, Ruby, Python, apenas uma quebra de linha é suficiente. Observe na Figura
2.9, que a linguagem C# precisa de ponto e vírgula no final da instrução e utiliza chaves para delimitar
o bloco if. Por enquanto, a linguagem Python não precisa de ponto e vírgula no final da instrução e
chaves para delimitar o bloco if.
107
Figura 2.9 - Declaração em C# e Python
Exemplo prático
Digite o comando “dotnet new console -n Declaracoes” no terminal para criar um programa. Abra o
programa no VS Code e copie o código abaixo. Deixe o mouse sobre a linha vermelha, localizada no
final da linha 9. Observe que o IntelliSense informa que é esperado um ponto e vírgula.
Figura 2.10 - Declaração sem ponto e vírgula
Ao tentar executar o programa, o compilador retorna um erro no terminal. O erro informa que é
esperado um ponto e vírgula na linha 9. Observe na Figura 2.11, que a linha 11 não foi executada, o
compilador não executa o programa se houver erro.
108
Figura 2.11 - Erro de compilação por falta de ponto e vírgula
Após inserir um ponto e vírgula no final da declaração, o compilador não gera mais erro. Observe na
Figura 2.12 que a linha 11 foi executada com sucesso.
Figura 2.12 - Programa executado com sucesso após inserir ponto e vírgula.
Declarações que utilizam chave, não precisam de ponto e vírgula. Observe na Figura 2.13, a linha 15
não precisa de ponto e vírgula.
109
Figura 2.13 - Declarações que utilizam chave não precisam de ponto e vírgula.
2.5 Espaços em Branco

Geralmente os espaços em branco, são importantes para os programadores organizarem o código,
tornando-o mais legível. Os espaços em branco na programação são chamados de indentação, que é
o recuo para organizar a estrutura do código. Observe um exemplo de indentação na Figura 2.14.
Figura 2.14 - Código indentado
Na maioria das linguagens os espaços em branco, não possuem um significado especial. Porém, para
algumas linguagens como Python, possuem um significado especial, alterando o comportamento do
código. Esses tipos de linguagem, usam a indentação para saber se a instrução pertence ou não a
determinado bloco.
110
Compare lado a lado o código C# e Python da Figura 2.15. Observe que a linguagem C#, usa uma
chave de abertura e uma de fechamento, para informar as instruções que pertencem ao bloco if. Já a
linguagem Python, utiliza a indentação. O código C# e Python executam as mesmas instruções, a
diferença é que Python está utilizando a indentação. Leia-se o código C# e Python do primeiro bloco,
da seguinte forma: Se a pontuação do jogador é maior que o recorde, o jogador recebe as mensagens
“Parabéns você é o novo recordista!” e “Obrigado por jogar!”.
O jogador que não bate o recorde, não recebe a mensagem “Obrigado por jogar!”. Queremos que a
mensagem “Obrigado por jogar!”, seja mostrada também aos jogadores que não bateram o recorde.
No segundo bloco é feito a correção. Observe que na linguagem C#, a instrução foi inserida fora da
chave e, no código Python, foi retirado o espaço em branco. Leia-se o segundo bloco da seguinte
forma: Se a pontuação do jogador é maior que o recorde, o jogador recebe a mensagem “Parabéns
você é o novo recordista!” e “Obrigado por jogar!”. Se a pontuação do jogador é menor que o recorde,
recebe apenas a mensagem “Obrigado por jogar!”.
Figura 2.15 - Diferença de Indentação entre C# e Python
Um código bem indentado, possui diferentes níveis de indentação. A Figura 2.16 possui quatro níveis
de indentação, que ajudam o programador a diferenciar quais instruções pertencem a cada bloco.
Cada seta de cor diferente, representa um nível diferente de indentação.
111
Figura 2.16 - Diferentes níveis de indentação
2.6 Comentários
Muitas vezes os programadores olham para o código e tem dificuldade de entender o propósito do
código. Isso acontece quando utilizamos códigos escritos por outros programadores ou até mesmo
escritos por nós a um tempo atrás. Isso é normal, não se assuste. Para facilitar esta tarefa podemos
comentar o código, escrevendo informações relevantes para facilitar a compreensão do código.
Para comentar o código em uma linha, deve-se utilizar duas barras no início do comentário. Esta é a
sintaxe para adicionar comentários em C# e várias outras linguagens. Os comentários são exibidos
numa cor diferente, para que você não confunda com o código regular. As cores variam de acordo
com cada editor de texto e configuração. Observe na Figura 2.17, que acima de cada instrução há um
comentário.
112
Figura 2.17 - Comentário de uma linha.
Para escrever comentários longos que ocupem mais de uma linha, deve-se usar uma barra seguida de
um asterisco, para abrir o campo de comentário e, um asterisco seguido de uma barra, para fechar o
campo de comentário. Um exemplo é apresentado na Figura 2.18.
Figura 2.18 - Comentário de múltiplas linhas
O compilador ou interpretador ignora as linhas comentadas, o código não é executado pelo CPU. Os
comentários não fazem nenhuma diferença no desempenho das aplicações. Intuitivamente, parece
interessante comentar todo o código, mas isto não é necessário. Um código bem elaborado deve ser
autoexplicativo, devemos deixar os comentários, para códigos que não podem ser autoexplicativos.
O código apresentado na Figura 2.19, possui um comentário, dizendo que o método a seguir, verifica
se o numero é par ou impar. Mas, o próprio nome do método já informa o que faz, além de ser um
código muito simples de ler. Neste caso, este seria um comentário desnecessário.
113
Figura 2.19 - Método comentado
Não se preocupe se você gosta de comentar seus códigos, no início do aprendizado, é muito
importante comentar os códigos, isto ajuda no processo de aprendizado. A medida que você se torna
mais experiente, é natural que os códigos pareçam cada vez mais autoexplicativos e você passa a usar
cada vez menos comentários. Isso também acontece, porque a qualidade do seu código melhora com
o tempo, se tornando cada vez mais legível.
Use comentários em seu código e com o passar do tempo vá reduzindo. Deixe somente comentários
necessários. Mas, não se esqueça, que você poderá ter que revisitar aquele código no futuro.
Em alguns casos pode-se utilizar os comentários como lembretes, marcar locais no código fonte, que
ainda precisam ser adicionados, consertados ou melhorados. Isto acontece, quando não terminamos
aquela instrução ou estamos aguardando uma instrução complementar, que está sendo desenvolvida
por outra pessoa da equipe. Neste caso, você pode simplesmente fazer um comentário.
Ao longo dos anos, algumas convenções, vem sendo utilizadas pelos programadores (convenção não
é regra), que facilitam a comunicação com outros programadores. Você pode criar suas próprias
convenções, desde que seja legível para os demais. Essas convenções, usam palavras pequenas
escritas em maiúsculo. As convenções mais conhecidas são:
• TODO: Significa “para fazer”, é algo que ainda precisa ser feito;
• FIXME: Significa “precisa ser consertado”, não está funcionando 100%;
• HACK: Significa que foi “usado uma programação rápida e suja”, que deve ser melhorada.
Essas palavras, não possuem nada de especial ou formal, apenas facilitam a comunicação entre a
equipe. Observe a Figura 2.20, qualquer programador que ler o comentário, saberá que precisar fazer
o cálculo de verificação.
114
Figura 2.20 - Comentário TODO
Comentários também podem ser usados para desativar o código temporariamente. Se o código está
sendo testado, é comum não querer executar uma determinada instrução. Por exemplo, se você não
quiser correr o risco que alguém chame o método VerificarPrimo, porque não está pronta, basta
comentar o código para não ser executado. Observe o método VerificarPrimo sendo comentado na
Figura 2.21.
Figura 2.21 – Código Comentado
115
3 VARIÁVEIS E
CONSTANTES
116
3.1 O que são variáveis
Se pudéssemos olhar dentro de um programa quando ele está em execução, veríamos muitos dados
individuais, como: endereço de e-mail, data de nascimento, pontuação, login e várias outras
informações. O programa armazena esses dados durante a execução através das variáveis. As
variáveis possibilitam que o programa reivindique uma parte da memória do computador, para usar
enquanto está em execução. Observe na Figura 3.1 os nomes das variáveis utilizadas no programa e
seus dados armazenados na memória.
Figura 3.1 - Variáveis e memória RAM
Uma variável em C# e nas outras linguagens de programação, é uma posição com nome e endereço
na memória, onde se armazena um valor que pode ser modificado. Quando um programa está sendo
executado, é necessário armazenar os resultados obtidos em tempo de execução ou armazenar as
entradas dos usuários, esses dados são armazenados em variáveis.
Na Figura 3.2 os nomes em rosa, representam as variáveis. Os valores que essas variáveis armazenam,
podem ser trocados a qualquer momento. O título pode ser alterado, a data de atualização, autor e
todos outros dados. Ao declarar uma variável, escolha um nome que descreva seu propósito.
117
Figura 3.2 - Variáveis armazenam dados em tempo de execução.
Algumas linguagens como C#, exigem que seja especificado um tipo para variável. Por exemplo, se
você especificar que a variável é do tipo numérica, não poderá atribuir uma letra a ela, se um tipo
diferente for atribuído, causará um erro. Primeiramente será apresentado, os tipos de dados de uma
forma mais ampla, para simplificar a explicação. Os tipos podem ser agrupados como caracteres,
numéricos e booleanos.
Para definir uma variável precisamos pensar em três coisas: tipo, nome e valor. O tipo define qual
será o tipo de dado, poderá ser um tipo numérico, caractere ou booleano. A variável poderá receber
diferentes dados, desde que sejam do mesmo tipo da variável. O nome é importante, para que o
programador possa identificar a variável quando precisar. O valor pode ser atribuído a variável
inicialmente ou no decorrer da execução do programa. A Figura 3.3 apresenta os 3 elementos
envolvidos na definição de uma variável.
118
Figura 3.3 - Elementos da variável.
As linguagens de programação, declaram as variáveis de forma muito similar, conforme apresentado

na Figura 3.5. Observe que existem diferenças na sintaxe, mas o conceito é o mesmo. O tipo “int” faz
parte do grupo do tipo numérico.
Figura 3.4 - Declaração de variável em diferentes linguagens.
119
No Swift a palavra-chave var define que “pontuação” é uma variável e a palavra-chave “int” define
o tipo da variável. No JavaScript para definir uma variável, apenas é necessário a palavra-chave var,
não precisa informar o tipo da variável. Em C++ e C#, é necessário colocar apenas o tipo e o nome,
não precisamos da palavra-chave var ou qualquer outra. A palavra-chave var utilizada nos exemplos
anteriores para definir uma variável em C#, também define um tipo, com base no tipo de dado a ser
atribuído.
Para declarar uma variável em C#, digite o tipo de dado, nome da variável e o operador de atribuição
“=” seguido do valor inicial a ser atribuído. O valor inicial atribuído na declaração da variável é
opcional. A Figura 3.5 apresenta um exemplo.
Figura 3.5 - Declaração de variável
Exemplo prático
Digite o comando “dotnet new console -n VariavelDeclaracao” no terminal para criar um programa.
Abra o programa no VS Code, copie o código da Figura 3.6, insira um breakpoint na linha 9 e inicie
o debug. Neste exemplo, foi declarada uma variável do tipo numérico int e um valor inicial foi
atribuído. Observe no campo do debug, o tipo da variável “pontuacao” é int.
120
Figura 3.6 - Definindo um tipo a variável
Antes de executar uma variável é necessário ter atribuído um valor, caso contrário, será retornado um
erro. No exemplo da Figura 3.7, nenhum valor foi atribuído a variável “pontuacao”, um erro é
retornado no terminal.
Figura 3.7 - Variável executada sem atribuição.
Para corrigir o erro atribua um valor a variável, conforme apresentado na Figura 3.8.
121
Figura 3.8 - Atribuição de valor a variável
3.2 Tipos de dados
Como toda linguagem de programação, C# apresenta um grupo básico de tipos de dados que já vem
implementado na linguagem. Esses tipos são conhecidos como tipos primitivos ou fundamentais. Os
diferentes tipos de dados podem ser agrupados em três categorias: caractere, numérico e booleano.
O tipo caractere suporta letras, números, símbolos e sinais de pontuação. Dentro desse grupo existem
dois tipos. O tipo char que armazena apenas um caractere por vez e o tipo string aceita uma cadeia de
caractere, armazenando vários por vez. O tipo booleano é o mais simples, só possui o tipo bool que
aceita dois valores: true ou false. Os tipos numéricos são utilizados para armazenar números, esses
números podem ser positivos ou negativos, possuir casas decimais ou não. Este tipo pode ser dividido
em dois subgrupos. O subgrupo numérico inteiro que possui 8 tipos inteiros e não aceita casas
decimais. E o subgrupo tipo numérico de ponto flutuante que possui 3 tipos numéricos e aceita casas
decimais.
Algumas linguagens de programação, obrigam que o tipo da variável seja especificado, são chamadas
de linguagens fortemente tipadas. No entanto, existem outras linguagens que não obrigam que o tipo
da variável seja especificado, são chamadas de linguagens fracamente tipadas. Em linguagens
fortemente tipada, a variável só aceita a atribuição de um dado do mesmo tipo. Por enquanto, em
linguagens fracamente tipada, a variável aceita a atribuição de diferentes tipos de dado. As linguagens
C#, C++, Java são fortemente tipada, por enquanto, PHP, JavaScript são fracamente tipada.
122
Inicialmente parece ser mais simples não precisar definir o tipo da variável, mas há desvantagens. Se
as regras não forem impostas sobre esses dados, provavelmente será necessário escrever mais código,
para garantir que os dados estejam corretos. Mesmo com essas diferenças, a maioria das linguagens
trata os dados de forma muito semelhante.
3.3 Char
O tipo char armazena apenas um caractere por vez, ocupando na memória 2 bytes (16 bits). Uma
variável do tipo char pode receber apenas um caractere por vez, que deve estar entre aspas simples.
Para declarar uma variável do tipo char, digite char, nome da variável, operador de atribuição simples
e o valor inicial entre aspas simples. A Figura 3.9 apresenta uma variável do tipo char sendo declarada.
Figura 3.9 - Declaração de variável do tipo char e atribuição de valor inicial.
Exemplo prático
Digite o comando “dotnet new console -n Caractere” no terminal para criar um programa. Abra o
programa no VS Code, copie o código da Figura 3.10 e execute o programa digitando o comando
“dotnet run” no terminal.
123
Figura 3.10 - Declaração de variável do tipo char e atribuição de valor inicial.
Se o valor atribuído estiver entre aspas duplas, o compilador entenderá que está sendo atribuído uma
string. Copie o código da Figura 3.11 e execute o programa com o comando “dotnet run”.
Figura 3.11 - Atribuição de valor do tipo string para variável tipo char.
Copie o código da Figura 3.12, insira um breakpoint na linha 13 e inicie o debug. Observe durante o
debug, que cada caractere possui um número ao lado, isso acontece, porque os caracteres são
representados internamente por um número. Os números são diferentes para cada tipo de caractere,
inclusive maiúsculo e minúsculo.
124
Figura 3.12 - Caracteres são representados internamente por números
ASCII e Unicode
Os caracteres possuem um número inteiro correspondente na

tabela ASCII (inglês American Standard Code for Information
Interchange; português - Código Padrão Americano para o
Intercâmbio de Informação). A codificação ASCII é usada para
representar textos em computadores, equipamentos de
comunicação, entre outros dispositivos que trabalham com
texto. Desenvolvida a partir de 1960, grande parte das
codificações de caracteres modernas a herdaram como base. A
partir da tabela ASCII outros tipos de tabelas foram criada, por exemplo, a Unicode que é um
superconjunto ASCII. Os números existentes na tabela ASCII tem o mesmo significado na tabela
Unicode. Por exemplo, o número 65 significa 'A' em ambas tabelas.
Você não pode salvar texto em seu disco rígido como "Unicode", porque é uma representação abstrata
do texto. Você precisa "codificar" esta representação abstrata, através da codificação UTF-8, UTF-
16 e UTF-32.
A codificação é o processo de transformar um conjunto de caracteres Unicode em uma sequência de

bytes. A decodificação é o processo de transformar uma sequência de bytes codificados em um
conjunto de caracteres Unicode. A codificação UTF-16 é usada pelo Common Language Runtime
para representar os valores Char e String.
Para saber mais acesse https://docs.microsoft.com/en-us/dotnet/standard/base-types/character-

encoding-introduction e https://docs.microsoft.com/en-us/dotnet/standard/base-types/character-
encoding.
125
3.4 string
Quando precisamos armazenar mais de um caractere, utilizamos o tipo string. O tipo string é uma
cadeia de caractere, ou seja, possui vários caracteres. Deve-se considerar, que uma string é mais
complexa para o computador do que os demais tipos. Simplesmente porque não se sabe o tamanho,
até que se forneça um valor ao computador. A quantidade de espaço alocado na memória só será
definida no momento que a variável receber o dado. Um tipo string pode conter uma palavra, uma
frase, um documento inteiro, não existe um limite. Os caracteres atribuídos a uma variável do tipo
string, podem ser letras, símbolos, números, qualquer tipo de caractere.
Para declarar uma variável do tipo string, digite string, nome da variável, operador de atribuição
simples e o dado entre aspas duplas. Um exemplo é apresentado na Figura 3.13.
Figura 3.13 - Declaração de variável do tipo string e atribuição de valor inicial
Exemplo prático
Digite o comando “dotnet new console -n String” no terminal. Abra o programa no VS Code, copie
o código da Figura 3.10, insira um breakpoint na linha 19 e inicie o debug. Neste exemplo, declaramos
a variável e atribuímos um valor a variável, observe a variável no painel de debug.
126
Figura 3.14 - Declaração de variável do tipo string e atribuição de valor inicial.
Uma string também pode armazenar apenas um caractere, conforme apresentado na Figura 3.15.
Figura 3.15 - Atribuição de um caractere a variável do tipo string.
É possível armazenar um texto com mil palavras ou muito mais. No exemplo da Figura 3.16 foi
atribuído mil palavras.
Figura 3.16 - Atribuição de mil palavras a variável do tipo string.
Para atribuir um valor tipo string deve ser utilizado aspas duplas. Se for utilizado aspas simples o
compilador entenderá que está sendo atribuído um caractere. Um exemplo é apresentado na Figura
3.17.
127
Figura 3.17 - Atribuição de dado do tipo char para variável do tipo string
3.5 bool
Costuma-se utilizar o tipo bool para indicar se houve ou não sucesso. Também para efetuar
comparações em expressões lógicas, como verificar se uma lâmpada esta acesa ou apagada. O tipo
bool possui dois valores: verdadeiro ou falso. Esses dois valores são suficientes para executar as
expressões lógicas. Observe como pode ser feito o uso do tipo bool na Figura 3.18.
Figura 3.18 - Lampada e tipo bool
O tipo bool ocupa na memória 1 byte (8 bits). Para declarar uma variável do tipo bool, digite bool
para definir o tipo de dado, nome da variável, operador de atribuição simples e o valor a ser atribuído.
A Figura 3.19 apresenta o uso da variável do tipo bool.
128
Figura 3.19 - Declaração de variável do tipo bool e atribuição.
Exemplo prático
Digite o comando “dotnet new console -n Bool” no terminal para criar um programa. Abra o programa
no VS Code, copie o código da Figura 3.20, insira um breakpoint na linha 10 e inicie o debug. Observe
que o valor true foi atribuído a variável.
Figura 3.20 - Declaração do tipo bool
Se nenhum valor for atribuído ao tipo bool, o valor padrão inicial é false. Observe a Figura 3.21.
129
Figura 3.21 - Valor padrão do tipo bool é false.
Mesmo que o tipo bool possua um valor padrão inicial, não é possível executar a variável se nenhum
valor foi atribuído. Se tentar executar a variável, o compilador retornará um erro, conforme
Figura 3.22 - Variável tipo bool sem atribuição
130
3.6 Diferença entre tipo numérico inteiro e tipo numérico de
ponto flutuante
Os tipos numéricos são utilizados para armazenar números, esses números podem ser positivos ou
negativos, possuir casas decimais ou não. Ao usar valores numéricos é necessário fazer essas
distinções para escolher o tipo numérico apropriado.
Dentro dos tipos de variáveis numéricas temos dois subgrupos distintos, números inteiros e números
de ponto flutuante. Se você tem um número sem casas decimais, deve utilizar algum tipo numérico
inteiro. Mas se você tem valores com casas decimais, deve utilizar algum tipo numérico de ponto
flutuante.
Distinguir entre tipos inteiro e ponto

flutuante é muito simples. Imagine que você
está desenvolvendo um software para um
estádio de futebol. O programa deve marcar
a quantidade de gols para mostrar no painel,
você não usará um número do tipo ponto
flutuante, porque não existe gol 1.3. Assim,
você saberá que deve usar um tipo de número
inteiro. O ingresso para assistir a partida de
futebol, tem casas decimais que representam
os centavos, por exemplo R$ 79,90. Logo, você saberá que precisa de um tipo numérico de ponto
flutuante, para armazenar os valores depois da vírgula que representam os centavos.
Os números inteiros e números de ponto flutuantes possuem diversos tipos, que são diferenciados
pelo tamanho máximo do número, quantidade de dígitos e se permitem sinal. Tipos diferentes ocupam
quantidades diferentes de espaço na memória.
Exemplo prático
Digite o comando “dotnet new console -n InteiroPontoFlutuante” no terminal para criar um programa.
Abra o programa no VS Code, copie o código da Figura 3.23 e debug o sistema. Observe no painel
do debug as variáveis e seus respectivos valores.
131
Figura 3.23 - Atribuição de tipo numérico ponto flutuante a tipo numérico inteiro
3.7 Tipo numérico inteiro
Os números inteiros são utilizados para registrar números que não

possuem casas decimais. Este tipo numérico suporta números
positivos e negativos. Se o tipo de dado é numérico e não possui
casas decimais, deverá ser usado um tipo numérico inteiro.
Se você estiver desenvolvendo um sistema para um elevador, é

provável que utilize o tipo inteiro para registrar o andar. Não faz
sentido usar um tipo numérico de ponto flutuante porque não existe
andar com casas decimais, por exemplo andar 9.8.
Existem 8 tipos de números inteiros, provavelmente o tipo int é o mais familiar. Os dados do tipo int
são armazenados em 4 bytes (32 bits) e o valor numérico limite é -2.147.483.648 a 2.147.483.647. O
segundo tipo mais usado é o tipo long que possui uma capacidade maior, os dados são armazenados
em 8 bytes (64 bits) e o valor numérico limite é -9.223.372.036.854.775.808 a
9.223.372.036.854.775.807. Os tipos numéricos inteiros são apresentados na Tabela 3-1.
Alocação
Tipo Valor Numérico Limite Sinal
Memória
sbyte -128 a 127 8 bits com sinal
byte 0 a 255 8 bits sem sinal
132
short -32.768 a 32.767 16 bits com sinal
ushort 0 a 65.535 16 bits sem sinal
int -2.147.483.648 a 2.147.483.647 32 bits com sinal
uint 0 a 4.294.967.295 32 bits sem sinal
-9.223.372.036.854.775.808 a
long 64 bits com sinal
9.223.372.036.854.775.807
ulong 0 a 18.446.744.073.709.551.615 64 bits sem sinal
Tabela 3-1 – Tabela de tipos numérico inteiro.
Para declarar uma variável do tipo int, digite int para definir o tipo de dado, nome da variável,
operador de atribuição simples e valor inicial. Um exemplo é apresentado na Figura 3.24.
Figura 3.24 - Declaração de variável do tipo int.
133
Para escolher o tipo apropriado, é necessário
saber qual o tamanho máximo do dado que se
espera e se pode ter ocorrências de números
negativos. Imagine que estamos desenvolvendo
um software de reservas de hospedagens de
hotéis e queremos criar um módulo de cadastro
de hotéis. Para definir as variáveis, é necessário
estipular alguns parâmetros (limite superior e
limite inferior) para escolher o tipo de dado
corretamente.
O hotel mais alto do mundo possui 828 metros,

para fazer o registro da altura do prédio, é
necessário selecionar o tipo de dado apropriado.
Analise a Tabela 3-1. O tipo sbyte possui valor
numérico limite de -128 a 127, o tipo byte de 0
a 255, logo sabemos que esses tipos possuem
um limite superior muito baixo. Continuando a
análise, temos o tipo short -32768 a 32767, esse
é um bom limite, mas aceita números negativos,
não existe altura negativa. O próximo item da
tabela é o tipo ushort com limite de 0 a 65535,
este é o tipo mais apropriado para variável
altura. Na sequência da tabela, existe outros
tipos que podem ser aplicados, mas eles ocupam mais espaços na memória. O tipo ushort ocupa 16
bits, por enquanto, o tipo uint que também poderia ser aplicado, ocupa 32 bits. Não faz sentido
desperdiçar memória, portanto, a melhor escolha é o tipo ushort.
Agora precisamos registrar a quantidade de andares, seguindo a mesma lógica. O tipo sbyte possui
valor numérico limite de -128 a 127, é um limite muito baixo e não queremos números negativos. O
próximo tipo é o byte com valor limite de 0 a 255, este tipo é suficiente para o nosso software, pois
temos como parâmetro o prédio mais alto do mundo que possui 160 andares. Se usar o tipo byte, o
software poderá aceitar sem nenhum problema um prédio com até 255 andares. As variáveis ficaram
definidas da seguinte forma:
• ushort predioAlturaMetro = 828

• byte predioQuantidadeAndar = 160
3.8 Tipo numérico de ponto flutuante
134
Os tipos numéricos de pontos flutuantes, devem ser utilizados para armazenar números que possuem
casas decimais, podendo ser positivo ou negativo. Alguns valores que usamos no mundo real,
obrigatoriamente precisam registrar as casas decimais, por exemplo:
• Temperatura = 39,7 ˚C;
• Distância em metros = 1,34 m;
• Parede metros quadrado = 23,4 m2
• Preço produto = R$ 1.997,90
É comum um valor decimal vir acompanhado de símbolo. Na programação não atribuímos o símbolo
como um dado a variável. O símbolo referente a unidade de medida, deve ser inserido por extenso no
nome da variável. Defina a casa decimal com ponto, não use vírgulas. Observe os exemplos:
• temperaturaCelsius = 39.7
• distanciaMetro= 1.34
• paredeMetroQuadrado = 23.4
• produtoPreco = 1997.90
Os valores monetários precisam de um pouco mais de atenção. Geralmente quando representamos

um valor em moeda Real, utilizamos o símbolo R$, ponto para dividir as casas e vírgula para as casas
decimais (salvo diferenças por ocasião). Na programação para armazenar os valores, não é utilizado
símbolos e vírgula. Só deve haver um ponto no lugar da vírgula, para representar as casas decimais.
Uma comparação é apresentada na Figura 3.25.
135
Figura 3.25 - Diferença entre representação normal e computacional de número decimal
Existem 3 tipos de pontos flutuantes, o tipo float, double e decimal. A diferença entre os tipos, é a
capacidade de dígitos que conseguem armazenar. Quanto maior a capacidade, mais memória será
ocupada.
Alocação
Tipo Quantidade de dígitos
memória
float 6 a 9 dígitos 4 bytes
double 15 a 17 dígitos 8 bytes
decimal 28 a 29 dígitos 16 bytes
Tabela 3-2 - Tipos flutuantes.
Para declarar uma variável do tipo decimal, digite decimal, nome da variável, operador de atribuição
simples e o valor inicial. Um exemplo é apresentado na Figura 3.26.
136
Figura 3.26 - Declaração de variável do tipo decimal.
Continuando o exemplo do software de hospedagem de

hotéis, agora vamos falar sobre valores. Precisamos
registrar o valor da diária do hotel, como estamos falando
de valor monetário, sabemos que possui casas decimais
que representam os centavos. Logo o tipo apropriado é o
tipo numérico de ponto flutuante.
Vamos analisar Tabela 3-2, o tipo float possui capacidade

de 6 a 9 dígitos, então devemos considerar que
dependendo o valor, só terá capacidade para armazenar 6
dígitos. Os valores das diárias de alguns hotéis podem
custar mais de R$ 100.000,00, esse tipo possui poucos
dígitos, precisamos de um tipo com mais dígitos. O
próximo tipo da tabela é o double que possui capacidade
de 15 a 17 dígitos, esse tipo é suficiente para registrar as
diárias do hotel.
Nem tudo é flores, o tipo double e float não são

apropriados para variáveis que envolvem cálculos
financeiros, porque fazem o arredondamento dos
números. A documentação da Microsoft orienta fazer o uso do tipo decimal, para tipos de dados
envolvidos em cálculos financeiros para que não ocorra erro de precisão.
O software precisa calcular o valor total da diária e outros serviços que o hóspede possa ter contratado.
O tipo decimal deve ser definido para o valor total. As variáveis ficaram definidas da seguinte forma:
137
• ushort predioAlturaMetro = 828
• byte predioQuantidadeAndar = 160
• decimal valorDiaria = 100000.00
Sufixo de ponto flutuante
Os sufixos definem o tipo de dado que está sendo atribuído. Os sufixos são identificados pelas letras
F, D e M para identificar os tipos float, double e decimal respectivamente. As letras podem ser,
maiúsculo ou minúsculo. Se o tipo de dado a ser atribuído não for especificado, o dado será tratado
como double. A sintaxe de atribuição da variável continua igual, apenas deve ser acrescentado o
sufixo atrás do número. Exemplo da sintaxe para cada tipo:
• valorFloat = 297.95F
• valorDouble= 297.95D
• valorDecimal= 297.95M
Exemplo prático
Digite o comando “dotnet new console -n PontoFlutuanteSufixo” no terminal para criar um programa.
Abra o programa no VS Code, copie o código da Figura 3.27 e execute o programa com o comando
“dotnet run” no terminal. Observe que o número atribuído está sem sufixo e nenhum erro é gerado.
Atribuições numéricas com casas decimais para variáveis do tipo double, não precisam de sufixo.
138
Figura 3.27 – Variáveis tipo double não precisam de sufixo no valor atribuído
Copie o código da Figura 3.28 e execute o programa. Observe que um erro foi gerado porque o
compilador espera uma atribuição do tipo float e não double.
Figura 3.28 - Variáveis do tipo float precisam de atribuição com sufixo.
Para corrigir o erro, digite o sufixo f ou F para definir o valor como float. Siga o exemplo da Figura
3.29.
139
Figura 3.29 - Acrescentando sufixo f na atribuição para tipo variável do tipo float
Precisão de tipos numéricos de ponto flutuante.

Os tipos numéricos de ponto flutuante mesmo que recebam os mesmos valores, podem gerar
resultados diferentes. O tipo float e double fazem o arredondamento de valores. Por enquanto, o tipo
decimal não faz o arredondamento, oferecendo uma precisão exata de valores. O tipo de dado Decimal
é apropriado para cálculos financeiros que exigem um grande número de dígitos fracionários
significativos e nenhum erro de arredondamento.
A soma de 26.5 + 0.1 com um tipo float obtém como resultado 26.600477. Mas a mesma soma com
decimal terá como resultado 26.6. Observe o exemplo da
Figura 3.30 - Precisão float e decimal.
140
Imagino que essa questão de arredondamento deixou você confuso, essa diferença ocorre porque o
decimal possui base 10, float e double possuem base 2. Não abordaremos este assunto nesse momento,
afinal queremos programar e não saber a origem do universo. Pelo menos por enquanto.
Exemplo prático
Digite o comando “dotnet new console -n PrecisaoPontoFlutuante” no terminal para criar um

programa. Abra o programa no VS Code. Copie o código da Figura 3.31 e, insira um breakpoint na
linha 9 e faça o debug passo a passo observando os valores das variáveis. Foram definidas 3 variáveis
de tipos diferentes: float, double e decimal. O valor inicial foi atribuído 26.5 para todas as variáveis
e posteriormente uma sequência de 5 somas com o valor 0.1. Todas as variáveis deveriam obter o
resultado final igual a 27.0, mas isto não ocorreu. As variáveis obtiveram resultados decimais
diferentes:
• float = 27.000479
• double = 27.000000000000007
• decimal = 27.0
Figura 3.31 - Diferença de precisão entre tipos numéricos de ponto flutuante
141
3.9 Conversão implícita e explícita.
As vezes é preciso transformar um tipo de dado em outro, isto é possível através da conversão. Por
exemplo, um número do tipo double, pode ser transformado em um número do tipo int e vice-versa.
A conversão pode ser feita de duas maneiras: implícita ou explícita. A conversão entre tipos
realizada automaticamente é conhecida como implícita , ocorre quando não precisamos
informar o tipo de conversão. A conversão explicita ocorre quando precisamos informar o tipo de
conversão, precisa ser feita manualmente com o operador cast ou a classe Convert por
exemplo.
Figura 3.32 - Tipos de conversões
Conversões entre tipos numéricos
142
As conversões implícitas podem ser feitas somente entre alguns tipos de dados. A Tabela
3-3 apresenta os tipos de conversão implícita.
de para
byte short, ushort, int, uint, long, ulong, float, double, decimal
char ushort, int, uint, long, ulong, float, double, decimal
float double
int long, float, double, decimal
long float, double, decimal
sbyte short, int, long, float, double, decimal
short int, long, float, double, decimal
uint long, long, float, double, decimal
ulong float, double, decimal
ushort int, uint, long, ulong, float, double, decimal
Tabela 3-3 – Conversões numéricas implícitas.
Os dados que podem ser convertidos explicitamente são apresentados na Tabela 3-4.
de para
byte byte ou char
char sbyte, byte ou short
decimal sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double
double sbyte, byte, short, ushort, int, uint, long, ulong, char, float, decimal
float sbyte, byte, short, ushort, int, uint, long, ulong, char, decimal
int sbyte, byte, short, ushort, uint, ulong, char
long sbyte, byte, short, ushort, int, uint, ulong, char
sbyte byte, ushort, uint, long, char
short Sbyte, byte, ushort, uint, ulong, char
143
uint Sbyte, byte, short, ushort, int, char
long sbyte, byte, short, ushort, int, uint, long, char
ushort Sbyte, byte, short, char
Tabela 3-4 - Conversões numéricas explicitas
Exemplo prático
Digite no terminal o comando “dotnet new console -n ConversaoNumericaExplicitaImplicita” para

criar um programa. Abra o programa no VS Code, copie o código da Figura 3.33 e insira um
breakpoint na linha 11 e faça o debug. A conversão implícita do tipo int para um tipo double ocorre
sem nenhum problema.
Figura 3.33 - Conversão numérica int para double.
Um tipo double não pode ser convertido implicitamente para um tipo int. Se tentar converter
implicitamente um tipo double para um tipo int, o compilador retornará um erro, informando que não
é possível, mas existe uma conversão explicita. Siga o exemplo da Figura 3.34.
144
Figura 3.34 - Conversão tipo double para tipo int implicitamente
A conversão de um tipo double para int deve ser feita de forma explícita, através do operador cast. O
operador cast possibilita fazer a conversão explícita entre tipos numéricos. Para usar o operador cast
insira entre parênteses o tipo para qual o dado deve ser convertido na frente do valor. Siga o exemplo
da Figura 3.35.
Figura 3.35 - Conversão explicita de double para int.
É possível converter implicitamente tipos inteiros para todos os tipos de ponto flutuante. Conforme
145
Figura 3.36 - Tipo inteiro convertido implicitamente para todos tipos de ponto flutuante
A conversão implícita de tipo inteiro para ponto flutuante também pode ser com números negativos,
Figura 3.37 - Conversão implícita de tipo inteiro negativo para ponto flutuante
Conversões entre tipo caractere e tipo numérico

As conversões não ocorrem apenas entre números, também podem ocorrer entre um tipo caractere e
numérico. A conversão de um tipo caractere para um tipo numérico, não pode ser feita através do
operador cast(), deve ser feita através da classe Convert. Não se preocupe, se você ainda não sabe o
que é classe ou método, mais adiante entraremos nesse assunto.
A classe Convert possui vários métodos que possibilitam fazer a conversão. A Tabela 3-5 apresenta
os métodos da classe Convert para converter string em números. Para ver a lista completa acesse o
link https://docs.microsoft.com/pt-br/dotnet/api/system.convert?view=netframework-4.8
Tipo numérico Método
decimal ToDecimal(String)
146
float ToSingle(String)
double ToDouble(String)
short ToInt16(String)
int ToInt32(String)
long ToInt64(String)
ushort ToUInt16(String)
uint ToUInt32(String)
ulong ToUInt64(String)
Tabela 3-5 - Conversão explicita com a classe Convert.
Digite o comando “dotnet new console -n ConversaoStringNumero” no terminal para criar um

programa. Abra o programa no VS Code, copie o código da Figura 3.38 e deixe o cursor depois do
ponto e pressione control + space. O intellisense mostrará os métodos disponíveis da classe Convert,
com uma descrição de cada método.
Figura 3.38 - IntelliSense auxilia na digitação do código.
Copie o código da Figura 3.39, insira um breakpoint na linha 12 e debug o código. Observe que a
conversão do tipo string para o tipo int ocorreu com sucesso.
147
Figura 3.39 - Conversão tipo string para int com classe Convert
O tipo string não pode ser convertido para o tipo numérico com o operador cast. Copie o código da
Figura 3.40 execute o programa. Um erro será apresentado.
Figura 3.40 - Conversão de tipo string para tipo int com operador cast
Copie o código da Figura 3.41, insira um breakpoint na linha 11 e debug o código. A conversão do
tipo char para o tipo int está sendo feita de forma implícita, com esta abordagem não conseguimos
148
obter o resultado esperado. Observe que a variável valorInteiro recebeu o número referente a tabela
Unicode e não o valor do número armazenado na variável. Como já visto, isso acontece porque cada
caractere é representado internamente por um número.
Figura 3.41 - Conversão implícita do tipo char para int.
A forma correta de fazer a conversão do tipo char para o tipo int é através do método
GetNumericValue da classe Char. É necessário usar o operador Cast porque o método transformou o
caractere em double e precisamos transformá-lo em int. Copie o código, insira um breakpoint na linha
11 e inicia o debug.
Figura 3.42 - Conversão explicita do tipo char para o tipo int
Tipos numéricos também podem ser transformados em tipo caractere. No exemplo da Figura 3.43
uma variável do tipo int é transformada em tipo string.
149
Figura 3.43 - Conversão explicita de tipo int para o tipo string.
3.10 Constantes
Até agora focamos em variáveis que são dados que podem ser alterados a qualquer momento. Mas
nem todos dados variam, alguns dados sempre devem permanecer igual. Por exemplo, um jogo pode
ter uma quantidade máxima de jogadores que o software suporta, esse valor fixo deve ser inserido
diretamente no código. Também temos o número PI que nunca muda, não faria sentido mudar o valor
de PI durante a execução da aplicação.
As constantes devem ser usadas em valores que não mudam, valores armazenados com constantes
ficam protegidos de qualquer alteração durante a programação ou a execução do programa.
Constantes e variáveis são muitos parecidas, possuem tipo, nome e valor conforme apresentado na
Figura 3.44. A única diferença, é que uma vez que o valor é atribuído não pode mais ser alterado.
Qualquer tentativa de alterá-lo depois da primeira atribuição causará um erro.
Figura 3.44 - Constantes
150
Dados armazenados como constantes, são mais eficientes que os mesmos dados armazenados como
variáveis. Porque a linguagem pode otimizar a memória de maneira diferente, se souber que os dados
nunca serão alterados.
Em algumas linguagens, é comum ver o nome de constantes escritas em maiúsculo e separadas por
um sublinhado, ao contrário das variáveis que costumam usar Camel Case. Isto não é uma regra, mas
é uma convenção que pode ajudar a identificar de forma rápida as constantes.
Talvez uma dúvida esteja pairando sobre você. Para que ser uma
constante, não seria mais fácil eu inserir o valor diretamente no
código? A resposta é não, porque a constante dará um sentido
para o valor inserido no código, devido ao seu nome. Imagine
você olhar no código o número 2 e ficar pensando, será que esse
é mesmo a quantidade máxima de jogador. Outra vantagem, é
não ter que ficar repetindo no código o mesmo valor, imagine
quando você quiser alterar um valor, terá que alterar em todo
código. Por exemplo, agora o jogo tem suporte para 4 jogadores,
se você não estiver usando constante, terá que alterar em todo
código o número 2 para 4. Com as constantes você precisará
alterar apenas em um único lugar.
Se você estiver desenvolvendo um sistema para um elevador, é provável que utilize uma constante
para registrar capacidade máxima em quilo do elevador. Não faz sentido usar uma variável, porque o
elevador foi projetado pra suportar um peso máximo fixo.
As constantes devem ser declaradas com a palavra-chave const, tipo, nome da constante, operador de
atribuição e o valor inicial. Um exemplo é apresentado na Figura 3.45.
Figura 3.45 - Declaração de constante
151
Exemplo prático.
Crie um programa digitando no terminal o comando “dotnet new console -n Constante”. Abra o
programa no VS Code. Copie o código da Figura 3.46.
Figura 3.46 - Declaração de constante
A atribuição do valor no momento da declaração da constante é obrigatória. Caso contrário, um erro

será retornado conforme apresentado na Figura 3.47.
Figura 3.47 - Constante não inicializada
Uma vez declarada a constante, o valor não poderá ser alterado. Caso contrário, um erro será
retornado conforme apresentado na Figura 3.48.
152
Figura 3.48 - Alterando valor da constante.
153
4 OPERADORES
ARITMÉTICOS
154
4.1 Introdução
Os operadores aritméticos são utilizados para fazer cálculos. O C# é uma linguagem rica em
operadores, que são representados por símbolos na construção de expressões. A sintaxe de expressão
do C# é baseada no C++. A Tabela 4-1 apresenta os 5 operadores aritméticos.
Operador Descrição
+ Adição
- Subtração
* Multiplicação
/ Divisão
% Resto ou Mod
Tabela 4-1 - Operadores Aritméticos
Quando os estudantes de programação estão lendo um livro técnico, muitas vezes não conseguem
resolver determinados problemas, não por terem dificuldades em matemática. Mas por não
conseguirem entender o enunciado do problema.
Um dos vários assuntos que são abordados nos primeiros anos de escola e esquecidos rapidamente, é
o nome dos termos (nomenclatura ou terminologia) utilizados nas quatro operações básicas
fundamentais: adição, subtração, multiplicação e divisão. Para entender melhor vamos fazer um passo
a passo bem simples, para relembrar esses termos. Só lembrando, que alguns termos podem ter
diferentes nomes, dependendo do país, tradução do livro e outros fatores.
4.2 Operador de adição

A operação de adição em C# utiliza o operador aritmético de adição, representado pelo símbolo “+”
(sinal de mais). Os valores envolvidos na operação são chamados de parcela e o resultado é chamado
de soma. Um exemplo é apresentado na figura tal.
155
Figura 4.1 - Termos da operação de adição
Exemplo prático
Digite no terminal o comando “dotnet new console -n OperadorAritmeticoAdicao” para criar um

programa. Abra o programa no VS Code, copie o código da Figura 4.2, insira um breakpoint na linha
13 e inicie o debug. A expressão 79 + 17 é representada pelo código parcelaA + parcelaB. O resultado
96 da expressão é atribuído a variável soma.
Figura 4.2 - Operação de adição
156
4.3 Operador de subtração
A operação de subtração utiliza o operador aritmético de subtração, representado pelo símbolo “-”
(sinal de menos). Os valores envolvidos na operação são chamados de minuendo e subtraendo, o
resultado é chamado de diferença. Um exemplo é apresentado na Figura 4.3.
Figura 4.3 - Termos da operação de subtração
Exemplo prático
Digite no terminal o comando “dotnet new console -n OperadorAritmeticoSubtracao” para criar um

13 e inicie o debug. A expressão 87 - 33 é representada pelo código “minuendo – subtraendo”. O
resultado 96 da expressão é atribuído a variável “diferenca”.
157
Figura 4.4 - Operação de subtração
4.4 Operação de Multiplicação

A operação de multiplicação utiliza o operador aritmético de multiplicação, representado pelo
símbolo “*” (asterisco). Os valores envolvidos na operação são chamados de multiplicando e
multiplicador, o resultado é chamado de produto. Um exemplo é apresentado na Figura 4.5.
Figura 4.5 - Termos da operação de multiplicação.
Digite o comando “dotnet new console -n OperadorAritmeticoMultiplicacao” no terminal para criar

um programa. Abra o programa no VS Code, copie o código da Figura 4.6, insira um breakpoint na
linha 12 e inicie o debug. A expressão 17 * 33 é representada pelo código “multiplicando *
multiplicador”. O resultado 68 da expressão é atribuído a variável produto.
158
Figura 4.6 - Operação de multiplicação.
4.5 Operador de divisão

A operação de divisão utiliza o operador aritmético de divisão, representado pelo símbolo “/” (barra).
Os valores envolvidos na operação são chamados de dividendo e divisor, o resultado é chamado de
quociente. Um exemplo é apresentado na Figura 4.7.
Figura 4.7 - Termos da operação de multiplicação
159
Exemplo prático
Digite o comando “dotnet new console -n OperadorAritmeticoDivisao” no terminal para criar um

12 e inicie o debug. A expressão 120 / 10 é representada pelo código “dividendo / divisor”. O
resultado 12 da expressão é atribuído a variável quociente.
Figura 4.8 - Operação de divisão
4.6 Operador módulo

A operação módulo encontra o resto de uma operação de divisão. A operação módulo é representado
pelo símbolo “%” (porcentagem). Os valores envolvidos na operação são os mesmos envolvidos na
operação de divisão, acrescido do termo resto. Os termos envolvidos são chamados de dividendo e
divisor, o resultado é chamado de resto ou mod. Um exemplo é apresentado na Figura 4.9
160
Figura 4.9 - Termos da operação módulo
Na programação o símbolo de porcentagem não é usado para calcular a porcentagem de um valor, se

você quer saber a porcentagem de um determinado valor deve-se utilizar a operação de multiplicação,
mais adiante será mostrado como fazer esta operação.
Os operadores aritméticos são muitos usados na programação, geralmente essas operações são feitas
usando variáveis e constantes, não são chamadas de parcela, fator, produto ou qualquer outra
nomenclatura matemática. Geralmente são nomeadas pelo real significado da regra de negócio, por
exemplo: valor total, preço unitário, gorjeta, frete, tamanho da pizza, valor ingresso, quantidade de
ingresso.
Exemplo prático
Digite no terminal o comando “dotnet new console -n OperadorAritmeticoModulo” parar criar um

programa. Abra o programa no VS Code, copie o código da insira um breakpoint na linha 12 e inicie
161
o debug. A expressão 123 % 10 é representada pelo código “dividendo % divisor”. O resultado 3 da
expressão é atribuído a variável resto.
Figura 4.10 - Operador divisão.
Exercício valor total dos ingressos
Desenvolva um programa que solicite a quantidade de ingressos que o usuário deseja e retorne o valor
total dos ingressos para o usuário. O valor do ingresso é R$ 89,99. O exercício resolvido é apresentado
na Figura 4.11
162
Figura 4.11 - Exercício operadores aritméticos calculando ingressos.
4.7 Precedência dos operadores

A precedência determina a ordem que os operadores serão executados. Os operadores aritméticos
seguem as regras algébricas típicas de hierarquia ou prioridade. A precedência é apresenta na Tabela
4-2.
Operador Exemplo Descrição Nível de precedência

+, - +36, -67 Determina positivo e negativo 1
*, /, % 5*4, 25/5, 9%4 Operação 2
+, - 2+7, 7-4 Operação 3
Tabela 4-2 - Precedência dos operadores aritméticos.
163
Expressões que possuem operadores de níveis de precedência diferentes, executam primeiramente os
operadores de nível mais alto. Um exemplo é apresentado na Figura 4.12.
Figura 4.12 - Níveis de precedência
Operadores aritméticos são associativos esquerdos, são avaliados da esquerda para direita. Nos casos
que houver operadores com a mesma precedência será executado da esquerda para direita. Por
exemplo, os operadores aritméticos de divisão e multiplicação possuem o mesmo nível de
precedência. A operação será executada da esquerda para direita, conforme apresentado na Figura
4.13.
164
Figura 4.13 - Associatividade a esquerda
A expressão que possuir operadores do mesmo nível e níveis diferentes, executará primeiro os
operadores de níveis mais alto da esquerda para direita e posteriormente os de níveis mais baixo da
esquerda para direita. Um exemplo é apresentado na Figura 4.14.
Figura 4.14 - Nível e precedência.
165
Parênteses podem ser usados para alterar a ordem de execução dos operadores aritméticos da
expressão. Observe a comparação entre os dois exemplos apresentado na Figura 4.15.
Figura 4.15 - Parênteses alteram a precedência.
Exemplo prático
No terminal digite o comando “dotnet new console -n OperadorAritmeticoPrecedenciaAssociativa”

para criar um programa. Abra o programa no VS Code, copie o código da Figura 4.16, insira um
breakpoint na linha 10 e inicie o debug. Os operadores da expressão 8 / 4 * 2 possuem o mesmo nível
de precedência, a expressão é avaliada da esquerda para direita. Primeiro executa-se a expressão 8 /
4 e o resultado obtido é multiplicado por 2.
166
Figura 4.16 - Operadores aritméticos de precedência igual.
Para executar a expressão 4 * 2 antes de 8 / 4 é necessário fazer o uso de parênteses. Insira a expressão
4 * 2 entre parênteses para alterar a ordem de execução. A expressão 4 * 2 é executada primeiro e seu
resultado é dividido por 8. Observe no painel de debug da Figura 4.17 que um resultado diferente foi
obtido.
Figura 4.17 - Alterando precedência com parênteses.
4.8 Exercício operações aritméticas e parênteses

A ordem de execução dos operadores, geram resultados diferentes. A expressão 6 + 3 * 4 / 2 + 2 gera
o resultado 14. Através do uso de parênteses na expressão, tente obter os seguintes resultados: 14, 9,
36, 11. O exercício resolvido é apresentado na Figura 4.18.
167
Figura 4.18 - Exercício resolvido uso de parênteses em operadores aritméticos.
4.9 Números positivos e negativos

O primeiro nível de precedência dos operadores aritméticos, determina se o número é negativo ou
positivo. Os números naturalmente são positivos, para transformar em negativo, é necessário utilizar
o sinal de menos antes do número. A representação de números positivos e negativos é apresentada
na Figura 4.19.
Figura 4.19 - Números positivos e negativos
As regras de sinais que usamos na matemática também são consideradas na programação, conforme
168
Figura 4.20 - Regras de sinais.
Observe na Figura 4.21 o comportamento das regras de sinais com a operação de multiplicação.
169
Figura 4.21 - Regras de sinais com multiplicação
Observe na Figura 4.22 o comportamento das regras de sinais com a operação de subtração.
Figura 4.22 - Regras de sinais operação de subtração
170
Respeitando a ordem de precedência a primeira operação realizada é transformar o número 2 em
negativo. Os operadores divisão e multiplicação possuem a mesma precedência, serão executados da
esquerda para a direita. O número 8 será dividido por 4 e o resultado será multiplicado por -2. O
resultado gerado é -4. O exemplo é apresentado na Figura 4.24
Figura 4.23 - Operação aritmética com sinal negativo
Exemplo prático
Digite o comando “dotnet new console -n OperadorAritmeticoMultiplicaçãoNumeroNegativo” no

terminal para criar um programa. Abra o programa no VS Code, copie o código da Figura 4.24, insira
um breakpoint na linha 13 e inicie o debug. Observe os resultados obtidos no painel de debug.
171
Figura 4.24 - Multiplicação com números negativos
4.10 Exercício média aritmética do aluno

Desenvolva um programa que calcule a média aritmética da nota de um aluno. O programa deve
perguntar ao usuário a nota referente a m1, m2, m3 e por fim apresentar a média. A média aritmética é
a soma dos valores, dividido pela quantidade de valores envolvido na soma. Para converter o valor
de entrada do tipo string para float utilize o método Convert.ToSingle(). O exercício resolvido é
172
Figura 4.25 - Exercício resolvido média aritmética do aluno
173
5 Operadores de
Atribuição
Composta
174
Além do operador de atribuição simples “=”, C# proporciona cinco operadores de atribuição
composta, que combinam o operador de atribuição simples com algum operador aritmético. São muito
utilizados como um atalho para fazer uma operação aritmética. Operadores de atribuição composta
realizam uma operação aritmética utilizando o operando a esquerda com o operando a direita,
atribuindo o resultado ao operando a esquerda. Um exemplo é apresentado na Figura 5.1 utilizando o
operador de atribuição composta e ao lado a operação equivalente com operador de atribuição
simples.
Figura 5.1 - Operador de atribuição composta com o equivalente operador de atribuição simples
Os operadores de atribuição composta possuem todos operadores aritméticos. A Tabela 5-1 apresenta
os operadores.
Símbolo Uso Equivalência Descrição
= x = y x=y Atribui o valor de y para x
*= x *= y x=x*y Multiplica x por y e atribui o resultado para x.
/= x /= y x=x/y Divide x por y e atribui o resultado para x
%= x %= y x=x%y Fixa x ao resto de x/y
+= x += y x=x+y Soma y e x e atribui para variável x.
-= x -= y x=x-y Subtrai y de x e atribui o resultado para variável x.
Tabela 5-1 - Atribuição composta
Operadores de atribuição composta abreviam a expressão. Se você deseja somar x + 3 e atribuir o

resultado a x, você pode usar a expressão x += 3. Observe o exemplo da Figura 5.2.
175
Figura 5.2 – Soma com atribuição simples e composta.
A Tabela 5-2 apresenta expressões com atribuição simples e a respectiva expressão com atribuição
composta. Considere o valor 50 para variável x.
Atribuição Simples Atribuição Composta Resultado
x=x*3 x *= 3 150
x=x/3 x /= 3 16
x = x% 3 x %= 3 2
x=x+3 x += 3 53
x=x-3 x -= 3 47
Tabela 5-2 - Atribuição simples e composta
Exemplo prático
Digite no terminal o comando “dotnet new console -n OperadorAtribuicao” para criar um programa.
o debug observando os resultados gerados.
176
Figura 5.3 - Operador de atribuição composta
Exemplo prático
Imagine que estamos desenvolvendo um jogo e queremos armazenar os pontos do jogador durante o
jogo. Existe a pontuação total do jogador que armazena todos os pontos feitos durante a partida e,
existe os pontos novos que foram adquiridos em uma nova jogada. Devemos adicionar os pontos
novos a pontuação total do jogador. No exemplo abordado, o jogador possui 800 pontos na partida e
conseguiu mais 300 pontos em uma nova jogada. Precisamos somar o valor 800 da pontuação mais o
valor 300, referente aos novos pontos adquiridos. O programa com o operador de atribuição simples
é apresentado na Figura 5.4 e o programa com o operador de atribuição composta é apresentado na
Figura 5.5.
177
Figura 5.4 - Pontuação com operador de atribuição simples
Figura 5.5 - Pontuação com operador de atribuição composta
178
6 OPERADORES
RELACIONAIS
179
6.1 Introdução
Os operadores relacionais permitem comparar dois valores, que são chamados de operandos. Se
utilizarmos um operando seguido de um operador relacional e outro operando, uma expressão
relacional é formada e um valor booleano será retornado. Os tipos numérico, caractere e booleanos
podem ser comparados pelo operador relacional. O exemplo da Figura 6.1 faz a comparação entre
dois operandos: se x for maior que y retorna true, se x for menor que y retorna false.
Figura 6.1 - Expressão condicional com dois operandos.
Existem seis tipos de operadores relacionais, a descrição e exemplo desses operadores é apresentado
na tabela Figura 6.2.
180
Operador Significado Exemplo
> Maior que x>y
< Menor que x<y
>= Maior ou igual que x >= y
<= Menor ou igual que x <= y
== Igual a x == y
!= Diferente de x != y
Figura 6.2 - Operadores relacionais
O valor retornado por uma expressão relacional, pode ser armazenado em uma variável do tipo bool.
Na expressão apresentada na Figura 6.3, a expressão avalia se 8 é maior ou igual a 4, como 8 é maior
que 4 a expressão retorna o valor true para variável resultado.
Figura 6.3 - Expressão relacional e retorno
Exemplo prático
Digite no terminal o comando “dotnet new console -n OperadorRelacional” para criar um programa.
o debug. O operador relacional verifica se 5 é maior que 3 e atribui o valor true para variável
resultado.
181
Figura 6.4 - Operador relacional maior que
A expressão geralmente é criada com uso de variáveis ou constantes. Copie o código da Figura 6.5,
insira um breakpoint na linha 12 e inicie o debug. Observe que a expressão relacional retorna true
porque x é maior que y.
Figura 6.5 - Operador relacional comparando variáveis.
Copie o código da Figura 6.6, a expressão avalia se “x” é menor que “y” e retorna o valor false.
182
Figura 6.6 - Operador relacional menor que.
Copie o código da Figura 6.7, a expressão avalia se “x” é igual a “y” e retorna o valor false.
Figura 6.7 - Operador relacional igual a
Copie o código da a Figura 6.8, a expressão avalia se “x” é diferente de “y” e retorna o valor true.
Figura 6.8 - Operador relacional diferente de
183
Copie o código da Figura 6.9, a expressão avalia se “x” é maior ou igual a “y” e retorna o valor true.
Figura 6.9 - Operador relacional maior ou igual a
Copie o código da a Figura 6.10, a expressão avalia se “x” é menor ou igual a “y” e retorna o valor
true.
Figura 6.10 - Operador relacional menor ou igual a

Expressões aritméticas podem ser comparadas pelos operadores relacionais. Expressões aritméticas
retornam um valor numérico, este valor quando retornado é comparado pelos operadores relacionais.
Um exemplo é apresentado na Figura 6.11
184
Figura 6.11 - Expressões aritméticas e operadores relacionais.
Em uma expressão com vários operadores, avalia-se os operadores pela ordem de prioridade de
precedência. Operadores relacionais possuem menor prioridade que os operadores aritméticos e
associatividade da esquerda para a direita. A ordem de precedência é apresenta na Tabela 6-1.
Operador Símbolo Nível de prioridade
Operadores Aritméticos +, -, *, /, % 1
Operadores Relacionais ==, !=, >, <, >=, <= 2
Tabela 6-1 - Precedência dos operadores aritméticos e operadores relacionais.
Operadores aritméticos são executados pelo programa antes dos operadores relacionais. Na Figura
6.12 operador aritmético de multiplicação é executado primeiramente, por possuir prioridade superior
ao operador de adição. Posteriormente o operador de adição é executado. Por último o operador
relacional compara os resultados das expressões aritméticas e retorna um valor booleano.
185
Figura 6.12 - Precedência dos operadores aritméticos e relacionais
Uma expressão relacional pode ter vários operadores relacionais, que são executados por ordem de
precedência e associatividade a esquerda. Os operadores relacionais “==” (igual a) e “!=” (diferente
de), possuem precedência diferente dos demais operadores relacionais e podem ser chamados de
operadores de igualdade, conforme apresentado na Figura 6.13.
Figura 6.13 - Subgrupo operadores de igualdade.
Operadores de igualdade possuem menor prioridade que os demais operadores relacionais e

associatividade da esquerda para direita.
186
Operadores relacionais <, >, <=, >= 1
Operadores de igualdade ==, != 2
Tabela 6-2 - Precedência dos operadores relacionais.
Uma expressão que possui operadores relacionais e operadores de igualdade, avalia-se primeiro os
operadores relacionais. Na Figura 6.14, o programa executa o operador relacional “>” (maior que) e
retorna o valor true. O operador de igualdade “!=” (diferente de) compara os dois operandos
booleanos “false != true” e retorna o valor true.
Figura 6.14 - Precedência dos operadores relacionais e operadores de igualdade
Operadores relacionais possuem associatividade a esquerda. A expressão que possuir operadores

relacionais do mesmo nível de prioridade, avaliará primeiro o operador mais a esquerda. Na Figura
6.15, o programa executa o operador relacional “>=” (maior ou igual a) por possuir nível de prioridade
maior e está mais a esquerda. Posteriormente o operador “>” (maior que) é executado por ter nível de
prioridade maior que o a “==” operador de (igualdade igual). Por último, é executado o operador de
igualdade igual a (==) que compara os dois valores booleanos.
187
Figura 6.15 - Operadores relacionais associatividade a esquerda.
Exemplo prático
Copie o código da Figura 6.16, insira um breakpoint na linha 10 e inicie o debug. O operador de
adição entre parênteses 3 + 7 é executado, o resultado 12 é dividido por 2 e obtém o valor 6. O
operador de subtração 12 – 5 é executado e retorna o valor 7. O operador relacional avalia se 7 é
maior que 5 e retorna true.
Figura 6.16 – Expressão com operadores relacionais e aritméticos
188
6.3 Tipos de operandos
Operadores relacionais e de igualdade podem comparar qualquer valor de tipo numérico (float,
double, int, long, etc.). Os tipos bool e string não podem ser comparados pelos operadores relacionais,
apenas pelos operadores de igualdade. O tipo char pode ser comparado pelos operadores relacionais
e de igualdade, a comparação é realizada pelo número referente a tabela Unicode.
Operadores de igualdade podem comparar qualquer tipo de dado primitivo. Os exemplos são
apresentados na Tabela 6-3 – Expressões com operadores de igualdade
Tipo dos operandos Expressão
Int 4 != 4
Decimal 4.17 == 8.45
Bool true != false
Char ‘x’ == ‘y’
String “Brasil” != “Holanda”
Tabela 6-3 – Expressões com operadores de igualdade.
Operadores relacionais podem comparar tipos numéricos e char. Os exemplos são apresentados na
Tabela 6-4.
Tipo dos operandos Expressão
Int 4<4
Decimal 4.17 > 8.45
char ‘x’ < ‘y’
Tabela 6-4 - Expressões com operadores relacionais.
O tipo char é comparado numericamente pelo seu valor referente a tabela Unicode. Por exemplo se
comparar os caracteres ‘x’ e ‘y’, será comparado os valores 120 e 121. Um exemplo é apresenta na
Figura 6.17
189
Figura 6.17 - Operador relacional com tipo char
Exemplo prático
Digite no terminal o comando “dotnet new console -n OperadorRelacionalTipoOperacao” para criar

um programa. Abra o programa no VS Code, copie o código da Figura 6.18, insira um breakpoint na
linha 12 e inicie o debug. O operador relacional verifica se x é maior que y e atribui o valor false
para variável resultado. Observe o que os valores estão sendo comparados pelos números referentes
a tabela Unicode.
Figura 6.18 - Operador relacional comparando tipo char
Copie o código da Figura 6.19, a expressão não pode comparar strings com operador relacional.
190
Figura 6.19 - Operador relacional não compara string
Copie o código da Figura 6.20, a expressão avalia se a string “jackson” é igual a “jackson” e retorna
o valor true.
Figura 6.20 - Operador de igualdade comparando string
Copie o código da Figura 6.21, a expressão avalia se a string “jackson” é igual a “Jackson” e retorna
o valor false. A expressão é falsa porque o operador diferencia maiúsculos e minúsculos.
191
Figura 6.21 - Operador relacional comparando string
192
7 Estrutura de
Seleção if
193
7.1 Instrução if
A instrução if é uma estrutura de seleção. Quando a instrução if é executada dentro de um programa,
é avaliada a expressão entre parênteses. Se a expressão é verdadeira, a instrução interna do bloco é
executada, caso contrário, não executa a instrução. Em qualquer caso, a execução do programa
continua com a instrução seguinte. A Figura 7.2 representa um diagrama de fluxo usando a instrução
if.
Figura 7.1 - Diagrama de fluxo instrução if
Para declarar a instrução if, insira a palavra-chave if e entre parênteses uma expressão booleana. As
instruções internas do bloco devem ser declaradas entre chaves. A estrutura da sentença if é
representada na Figura 7.2.
194
Figura 7.2 - Estrutura if.
O fluxograma da Figura 7.3 verifica se a média do aluno é maior ou igual 6. Se a média for maior
ou igual a 6 apresenta a mensagem Aluno Aprovado. Se a média for menor, nenhuma mensagem é
apresentada e o fluxo do programa continua normalmente. Observe o código correspondente ao
lado.
Figura 7.3 - Fluxograma aluno aprovado.
195
Exemplo prático
Digite no terminal o comando “dotnet new console -n InstrucaoIf”. Abra o programa no VS Code,
copie o código da Figura 7.4, insira um breakpoint na linha 14 e inicie o debug. O programa calcula
a média aritmética do aluno e verifica se o aluno foi aprovado. Se a média for maior ou igual a 6,
apresenta a mensagem “Aluno Aprovado”. Neste exemplo, a média do aluno é 6.53, o aluno foi
aprovado. A execução da instrução Console.WriteLine($“Média final:{media}”) é executada
indiferente do bloco if, por não esta dentro das chaves.
Figura 7.4 - Instrução if aluno aprovado
Insira o valor 5.5 na m1, a média do aluno passa a ser 5.26, conforme apresentado na Figura 7.5. A
instrução if verifica se a média é maior ou igual a 6. Neste caso a média é menor, a instrução
Console.WriteLine(“Aluno Aprovado”) não é executada, somente a instrução
Console.WriteLine($“Média final:{media}”) é executada.
196
Figura 7.5 - Instrução if média do aluno
7.2 Exercício controle de entrada de menores no parque

Desenvolva um programa que controle a entrada dos clientes em um parque de diversão. O programa
deve solicitar o nome e idade do cliente. Se a idade do cliente for menor que 18 anos o programa deve
solicitar o nome do responsável. Verifique o diagrama da Figura 7.6 para auxiliar na construção do
código. O exercício resolvido é apresentado na Figura 7.7.
197
Figura 7.6 - Fluxograma instrução if menor de idade
198
Figura 7.7 - Exercício resolvido instrução if menor de idade
7.3 Instrução if-else

Um segundo formato da instrução if é a instrução if-else. Quando a sentença if-else é executada,
avalia-se a expressão da seguinte forma: Se a expressão for verdadeira, executa a instrução 1, se for
falsa, executa a instrução 2. Observe que apenas uma das instruções, podem ser executadas, se a
instrução 1 é executada, a instrução 2 não é executada, se a instrução 1 não é executada a instrução 2
é executada. O fluxograma da instrução if-else é apresentado na Figura 7.8.
199
Figura 7.8 - Fluxograma instrução if-else.
A estrutura da instrução if-else é parecida com a instrução if, a diferença é que adicionamos a palavra-
chave else, seguida de mais um bloco de instrução.
200
Figura 7.9 - Estrutura da instrução if-else
O fluxograma e o código correspondente da sentença if-else é apresentada na Figura 7.10. Se a média

do aluno for maior ou igual a 6, o aluno é aprovado, caso contrário, é reprovado. Observe que o
programa pode mostrar apenas uma das instruções.
Figura 7.10 - Instrução if-else fluxograma aluno aprovado ou reprovado
201
Exemplo prático
Digite no terminal o comando “dotnet new console - n InstrucaoIfElse” para criar um programa. Abra
o programa no VS Code, copie o código da Figura 7.11, insira um breakpoint na linha 14 e inicie o
debug. O programa calcula a média aritmética do aluno e verifica se o aluno foi aprovado ou
reprovado. Se a média for maior ou igual a 6, apresenta a mensagem “Aluno Aprovado”. Caso
contrário, apresenta a mensagem “Aluno Reprovado”. Neste exemplo, a média do aluno é 6.53, o
programa apresenta as mensagens “Aluno aprovado” e “Média final: 6.53”.
Figura 7.11 - Instrução if-else média do aluno aprovado
Insira o valor 5.5 na variável m1, a média do aluno passa a ser 5.26, conforme apresentado na Figura
7.12Figura 7.5. A instrução if verifica se a média é maior ou igual a 6, como não é, o bloco else é
acionado e executa a instrução Console.WriteLine(“Aluno Reprovado”). O programa continua o
fluxo normal e executa a instrução Console.WriteLine($“Média final:{media}”).
202
Figura 7.12 - Instrução if-else média do aluno reprovado
7.4 Instrução if-else aninhada

Até este momento, as instruções if implementam decisões que implicam em uma ou duas alternativas.
Nesta seção, será explicado como se pode utilizar a sentença if-else aninhada, que permite
implementar decisões com várias alternativas. A estrutura da instrução if-else aninhada é apresentada
na Figura 7.13.
203
Figura 7.13 - Estrutura da instrução if-else aninhada
O fluxograma e o código correspondente da sentença if-else aninhada é apresentada na Figura 7.14.

Se a média do aluno for maior ou igual a 6, o aluno é aprovado. Se a média do aluno for maior ou
igual a 5 e menor que 6 o aluno fica em recuperação. Se a nota do aluno for menor que 5 é reprovado.
204
Figura 7.14 – Instrução if-else aninhada aluno aprovado, em recuperação e reprovado
Exemplo prático
Digite no terminal o comando “dotnet new console -n InstruçãoIfElseAninhada” para criar um

programa. Abra o programa no VS Code, copie o código da Figura 7.15, insira um breakpoint na
linha 14 e inicie o debug. O programa calcula a média aritmética do aluno e verifica se foi aprovado,
ficou em recuperação ou foi reprovado. Se a media é igual ou maior que 6 o aluno é aprovado. Se a
média do aluno for maior ou igual a 5 e menor que 6 o aluno fica em recuperação. Se a nota do aluno
for menor que 5 é reprovado. A média do aluno é 7.4, a instrução if é executada e apresenta a
mensagem “Aluno aprovado”.
205
Figura 7.15 - Instrução if-else aninhada aluno aprovado.
Insira o valor 5.5 na variável m1 e 6.2 na m2, a média do aluno passa a ser 5.4 conforme apresentado
na Figura 7.16. A instrução else-if é executada e apresenta a mensagem “Aluno em recuperação”.
Figura 7.16 - Instrução if-else aninhada aluno em recuperação.
206
Insira o valor 4.2 na variável m1, a média do aluno passa a ser 4.2 conforme apresentado na Figura
7.17. A instrução else-if é executada e apresenta a mensagem “Aluno Reprovado”.
Figura 7.17 - Instrução if-else aninhada reprovado.
7.5 Exercício controle de entrada nos brinquedos do parque

Um parque de diversão possui vários tipos de brinquedos radicais, esses brinquedos são categorizados
por faixa etária. Para que os funcionários do parque, possam fazer o controle das pessoas que acessam
os brinquedos, cada cliente recebe uma fita de acordo com a faixa etária. Se o cliente possui idade
menor ou igual a 6 anos, recebe fita vermelha. Se possui idade entre 7 a 12 anos, recebe fita amarela.
Se possui idade maior ou igual a 13, recebe fita verde. Se possui idade superior ou igual a 70 anos,
recebe fita amarela. Desenvolva um programa que informe a cor da fita de cada cliente de acordo
com a idade. O exercício resolvido é apresentado na Figura 7.18.
207
Figura 7.18 - Exercício resolvido instrução if-else aninhada cor da fita.
208
7.6 Escopo de bloco
O escopo determina quais são os dados que podem ser acessados em uma determinada parte do
código, essas partes podem ser chamadas de blocos. As variáveis declaradas dentro de um bloco,
possuem escopo de bloco e não são visíveis fora do bloco.
A instrução if é um bloco. Uma variável declarada dentro de um bloco, poderá ser referenciada em
qualquer parte do bloco, do ponto em que foi declarada até o final do bloco. Mas não poderá ser
referenciada fora do bloco.
Na variável mensagem foi declarada dentro do bloco if e também no bloco else. Somente foi possível
declarar uma variável com o mesmo nome, porque a variável foi declarada em escopos diferentes. A
instrução Console.WriteLine(mensagem) não consegue executar a variável “mensagem”, porque um
bloco externo não pode acessar as propriedades de um bloco interno. Por outro lado, o bloco interno
pode acessar as propriedades do bloco externo, por exemplo a instrução if acessou as variáveis
numeroA e numeroB do bloco externo.
Figura 7.19 - If escopo de bloco
Exemplo prático
Digite no terminal o comando “dotnet new console -n EscopoBlocoIf” para criar um programa. Abra
o programa no VS Code, copie o código da Figura 7.20 e execute o programa com o comando dotnet
run. O programa verifica entre dois números qual é o maior. Observe que um erro foi gerado, a
instrução Console.WriteLine(mensagem) do bloco externo está tentando acessar a propriedade de um
bloco interno.
209
Figura 7.20 - Instrução if escopo de bloco errado
Para corrigir o problema declare a variável “mensagem” no bloco externo, fora da instrução if e else.
O exemplo é apresentado na Figura 7.21.
210
Figura 7.21 - Instrução if escopo de bloco
211
8 ESTRUTURA DE
REPETIÇÃO
WHILE
212
8.1 Instrução while
A instrução while representa uma estrutura de repetição, permite chamar várias vezes uma ou várias
instruções, por enquanto a condição for verdadeira. A instrução while representa um laço de repetição,
que também pode ser chamado de loop.
O fluxograma de uma instrução while é apresentada na Figura 8.1. Se a condição for verdadeira,
executa as instruções internas do laço e retorna ao inicio reavaliando a condição do laço. Se a condição
do laço for falsa, as instruções internas do while não são executadas e o programa continua no fluxo
normal do programa.
Figura 8.1 - Fluxograma instrução while.
213
Para declarar uma instrução while é utilizado a palavra-chave while. Entre parênteses uma expressão
booleana deve ser inserida. Entre chaves deve ser inserida as instruções a serem executada a cada
iteração do laço. A estrutura é apresentada na Figura 8.2.
Figura 8.2 - Estrutura da instrução if
Um laço é uma construção de programa, que repete uma instrução ou sequência de instruções
determinado número de vezes. Cada repetição do corpo do laço se chama iteração do laço. O exemplo
apresentado na Figura 8.3 possui 11 iterações, que apresentam no terminal a contagem de 0 a 10.
214
Figura 8.3 - Instrução while iterações.
Exemplo prático
Digite no terminal o comando “dotnet new console -n “InstrucaoWhileContador” para criar um

programa. Abra o programa no VS Code, copie o código da Figura 7.20 e execute o programa com o
comando “dotnet run”. O programa inicia a contagem em 0 e termina em 10, totalizando 11 iterações.
215
Figura 8.4 – Instrução while contador
8.2 Laços que nunca executam.
A condição do laço precisa ser verdadeira para iniciar a execução do laço. Se a condição for falsa o
laço nunca é iniciado. É comum programadores iniciantes, escrever condições de laço como se fossem
o critério de parada, mas na verdade o que devemos escrever é o critério de execução do laço.
Um laço para ser executado precisa que condição seja verdadeira. No exemplo da Figura 8.5, o
contador é inicializado com o valor 0 e a condição do laço, exige que o contador seja igual a 10 para
executar o laço. O contador nunca chegará a 10, porque a atualização do contador está dentro do laço,
que nunca será executado. Neste caso, uma condição depende da outra, não sendo possível executar
o laço.
216
Figura 8.5 - Laços que nunca executam
Exemplo prático
Digite no terminal o comando “dotnet new console -n “InstrucaoWhileNuncaExecuta” para criar o

comando “dotnet run”. Observe que nenhuma iteração acontece porque a condição do laço é sempre
falsa.
Figura 8.6 - Laços que nunca executam.
217
8.3 Laços Infinitos
Se a condição for sempre verdadeira, um laço infinito será criado. A condição em algum momento
deve ser falsa, para que o laço pare a execução. No exemplo da Figura 8.7 o contador nunca é
atualizado, sempre será zero. A condição do laço sempre retorna true, fazendo com que o laço
continue sendo executado.
Figura 8.7 - Instrução while laços infinitos
Exemplo prático
Crie um programa digitando no terminal o comando “dotnet new console -n “InstrucaoWhileInfinito”.

Abra o programa no VS Code, copie o código da Figura 8.8 e execute o programa com o comando
“dotnet run”. Observe que o contador é sempre zero, o laço continua sendo executado infinitamente.
Clique no terminal e pressione “control + c” para terminar a execução do programa.
218
Figura 8.8 - Instrução while laços infinitos
219
8.4 Laços Aninhados
Um laço aninhado é um laço com um ou mais laços internos. A cada iteração do laço externo, os laços
internos iteram até a condição do laço for falsa. Um laço aninhado é categorizado em laço externo e
interno, conforme apresentado na Figura 8.9.
Figura 8.9 - Instrução while laços aninhados.
Quando o laço externo executa uma iteração, o laço interno executa todas iterações. Quando termina
as iterações do laço interno o programa retorna ao laço externo para reavaliar a condição. Um exemplo
é apresentado na Figura 8.10.
Figura 8.10 – Instrução while iterações de laços aninhados.
Se houver instruções após o laço interno, serão executadas antes de retornar à condição do laço
externo. Um exemplo é apresentado na Figura 8.11.
220
Figura 8.11 – Instrução while laço externo com instrução após laço interno.
O exemplo apresentado na Figura 8.13 exibe no terminal a tabuada de 1 a 10. A tabuada inicia em 1
x 1 = 1 e termina em 10 x 10 = 100.
Figura 8.12 - Instrução while tabuada
Exemplo prático
Digite no terminal o comando “dotnet new console -n “InstrucaoWhileAninhadoTabuada” para criar

um programa. Abra o programa no VS Code, copie o código da Figura 8.13 e execute o programa
com o comando “dotnet run”.
221
Figura 8.13 - Tabuada com laços while aninhados
222
8.5 Instrução Break
É possível interromper a qualquer momento um bloco de instrução while utilizando a instrução
“break”. Se um laço precisa ser interrompido antes do previsto a instrução break pode ser utilizada.
No exemplo da Figura 8.14, se a condição da instrução “if” for verdadeira, a instrução “break” é
executada, a instrução 1 não é executada e a instrução 2 é executada.
Figura 8.14 - Instrução break.
Uma instrução break pode ser usada dentro de um laço com condição true. A instrução break deve
estar dentro de uma estrutura condicional, por exemplo uma instrução if. Se não houver nenhuma
estrutura condicional, a instrução break será executada na primeira iteração e o laço será interrompido.
Um exemplo de validação de menu é apresentado na Figura 8.15, o laço só é interrompido se o usuário
digitar “n”.
223
Figura 8.15 - While com condição true e instrução break
8.6 Exercício contador de 0 a 10 com instrução break

Desenvolva um contador de 0 a 10 que utilize true como condição do laço e break para interromper
o laço. O exercício resolvido é apresentado na Figura 8.16.
224
Figura 8.16 - Instrução break com contador.
225
9 OPERADOR
LÓGICO
226
Operadores lógicos comparam duas ou mais expressões booleanas e retornam um valor booleano.
Também pode inverter o valor de um operando ou resultado de uma expressão booleana. São
utilizados em expressões condicionais mediante a instrução if, while, for, switch, do-while. Um
exemplo é apresentado na Figura 9.1. Os operadores lógicos são: not (!), and (&&) e or (||).
Figura 9.1 - Operador lógico em expressão condicional
Expressões booleanas é toda expressão

que retorna um valor booleano como
resultado. Por exemplo, uma expressão
relacional é uma expressão booleana.
Logo uma expressão lógica é uma
expressão booleana.
9.1 Operador not (!)

O operador lógico not é representado pelo símbolo (!), este operador inverte o valor de um operando
booleano. Se o operando é true será produzido false. Se o operando é false será produzido true. Um
exemplo e apresentado na Figura 9.2.
227
Figura 9.2 - Operador "!" (not).
O operador lógico “not” somente inverte o valor de um operando booleano. Se o operador not for
inserido numa expressão booleana, somente o operando que o segue será alterado e não toda
expressão. Observe no primeiro exemplo da Figura 9.3, que o operador “!” (not) tenta alterar o
primeiro operando e não toda expressão, um erro é gerado porque o operando é do tipo int. O mesmo
problema se repete no segundo exemplo, porque o operando é do tipo char.
228
Figura 9.3 - Operador lógico "!" not altera apenas o primeiro operando.
Para inverter o valor da expressão booleana, é necessário inserir parênteses em torno da expressão.
Os parênteses transformam a expressão booleana em um único operando booleano. Um exemplo é
229
Figura 9.4 – Operador "!" (not) parênteses em expressões booleanas.
Na Figura 9.5 a primeira expressão verifica se 7 é menor ou igual a 4, como a expressão é falsa retorna
false. Na segunda expressão temos a mesma expressão, 7 é menor ou igual a 4, a expressão retorna
false, mas o operador not (!) inverte para true.
230
Figura 9.5 - Operador "!" (not) e operador relacional
Exemplo prático.
Digite no terminal o comando “dotnet new console -n “OperadorLogicoNot” para criar um programa.
o debug.
Figura 9.6 - Operador "!" (not) inverte resultado
Copie o código da Figura 9.7 e digite o comando “dotnet run” no terminal para executar o programa.
Observe que o compilador retorna um erro, informa que o operador lógico "!" (not) não pode ser
aplicado ao tipo int.
231
Figura 9.7 - Operador lógico "!" (not) não pode ser aplicado a tipo numérico
O uso de parênteses em volta da expressão corrige o erro, conforme apresentado na Figura 9.8.
Figura 9.8 – Operador "!" (not) e uso de parênteses.
9.2 Exercício números impares de 0 a 100

Desenvolva um programa que apresente os números impares de 0 a 100. Utilize o operador not (!).
O exercício resolvido é apresentado na Figura 9.9 e o resultado na Figura 9.10.
232
Figura 9.9 - Exercício resolvido números impares de 0 a 100.
233
Figura 9.10 - Resultado do exercício números impares de 0 a 100.
9.3 Operador and (&&)

O operador lógico && (and) produz verdadeiro somente se ambos os operados são verdadeiros. Se
qualquer um dos operandos for falso, produz falso. A forma mais usual de mostrar os resultados das
operações lógicas é mediante a tabela verdade, que mostra como funciona cada um dos operadores
lógicos. A tabela verdade do operador lógico and é apresentada na Tabela 9-1.
234
Expressão Resultado
true &&| true true
true && false false
false && true false
false & false false
Tabela 9-1 - Tabela verdade do operador lógico "&&" (and)
Geralmente utiliza-se operadores lógicos para comparar expressões relacionais. As expressões

relacionais são operandos de uma expressão lógica. O operador lógico compara os resultados gerados
pela expressão relacional, conforme apresentado na Figura 9.11.
Figura 9.11 - Expressão relacional e operandos.
Expressões com operadores relacionais e lógicos seguem uma ordem de prioridade. Primeiramente
avalia-se a expressão relacional e um resultado booleano é obtido. Posteriormente os resultados
booleanos obtidos são comparados pelo operador lógico. Por fim, um resultado booleano é obtido.
Um exemplo é apresentado na Figura 9.12.
235
Figura 9.12 - Precedência dos operadores relacionais e lógicos.
Exemplo prático.
Digite no terminal o comando “dotnet new console -n “OperadorLogicoAnd” para criar um programa.
o debug. Observe que apenas a primeira expressão retornou true, por ser a única expressão que possui
os dois operandos com o valor true.
Figura 9.13 - Operador Lógico "&&" (and)
236
Copie o código da Figura 9.14, insira um breakpoint na linha 9 e inicie o debug o código.
Primeiramente foi obtido o valor das expressões relacionais e por último os resultados são
comparados em uma expressão lógica.
Figura 9.14 - Expressão relacional e operador lógico "&&" (and).
Copie o código Figura 9.15, insira um breakpoint na linha 9 e debug o código. Leia as expressões e
compare com os resultados apresentados na janela do debug.
Figura 9.15 - Operador lógico "&&" (and) e expressões relacionais
237
9.4 Exercício número entre 0 e 100
Desenvolva um programa que solicite ao usuário um número entre 0 e 100. Se o número digitado for
entre 0 e 100, o programa deve apresentar uma mensagem de agradecimento. Caso contrário, deve
apresentar uma mensagem de erro e solicitar um novo número. Os números entre 0 e 100 iniciam em
1 e terminam em 99. Utilize o operador lógico "&&" (and). O exercício resolvido é apresentado na
Figura 9.16. Teste seu código com os números 127, -49, 0, 100 e 33. Verifique se obteve os mesmos
resultados da Figura 9.17.
Figura 9.16 - Exercício resolvido números entre 0 e 100
238
Figura 9.17 - Teste do exercício número entre 0 e 100.
9.5 Operador or (||)

O operador lógico “||” (or) produz verdadeiro se qualquer um dos operandos for verdadeiro e produz
falso somente se ambos operandos forem falsos. A forma mais usual de mostrar os resultados de
operações lógicas é através da tabela verdade, que representa o funcionamento dos operadores
lógicos. A tabela verdade do operador lógico or é apresentada na Tabela 9-2
Expressão Resultado
true || true true
true || false true
false || true true
false || false false
Tabela 9-2 - Tabela verdade operador lógico “||” (or).
Geralmente utiliza-se operadores lógicos para comparar expressões relacionais. As expressões

relacionais são operandos de uma expressão lógica. O operador lógico compara os resultados gerados
pela expressão relacional. Um exemplo é apresenta na Figura 9.18.
239
Figura 9.18 - Expressões relacionais são operandos de expressões lógicas.
As expressões com operadores relacionais e lógicos seguem uma ordem de prioridade. Primeiramente
avalia-se a expressão relacional, um resultado booleano é obtido. Posteriormente os resultados
booleanos obtidos são comparados pelo operador lógico. Por fim, um resultado booleano é obtido.
Um exemplo é apresentado na Figura 9.19
240
Figura 9.19 - Expressão lógica com expressões relacionais.
Um exemplo utilizando operador lógico comparando os resultados das expressões relacionais é

241
Figura 9.20 - Expressões relacionais e operador lógico “||” (not).
Exemplo prático
Digite no terminal o comando “dotnet new console -n “OperadorLogicoAnd” para criar um programa.
o debug. Observe que apenas a primeira expressão retornou false, porque é a única expressão que
possui os dois operandos false.
242
Figura 9.21 -Operador lógico “||” (not) e valores booleanos.
Copie o código da Figura 9.22, insira um break point na linha 9 e debug o código. Primeiramente foi
obtido o valor das expressões relacionais separadamente e por último foi comparado os resultados em
uma expressão lógica.
Figura 9.22 - Expressão relacional e operador lógico "||" (or).
Copie o código da Figura 9.23, insira um breakpoint na linha 9 e debug o código. Leia as expressões
e compare com os resultados apresentados na janela do debug.
243
Figura 9.23 - Expressão relacional e operador lógico "||" (or).

Os operadores aritméticos, relacionais, lógicos e de atribuição possuem precedência um sobre o outro.
Operadores aritméticos tem prioridade sobre operadores relacionais. Operadores relacionais tem
prioridade sobre operadores lógicos. Operadores lógico tem prioridade sobre operadores de
atribuição.
Operador Símbolos Nível de prioridade

Aritmético +, -, *, /, % 1
Relacional >, <, >=, <=, ==, !=, 2
Lógico !, &&, || 3
Atribuição =, +=,, -=, *=, /= %= 4
Tabela 9-3 - Precedência dos operadores
Os operadores de maior nível de prioridade são executados primeiro. Por exemplo, os operadores
aritméticos são executados antes dos operadores relacionais, que por sua vez, são executados antes
dos operadores lógicos. Observe a ordem de execução dos operadores na expressão apresentada na
Figura 9.24.
244
Figura 9.24 - Precedência dos operadores
9.7 Precedência dos operadores lógicos

O operador “!” (not) possui prioridade mais alta que o operador “&&” (and). O operador “&&” (and)
possui prioridade mais alta que o operador “||” (or). Os operadores lógicos possuem associatividade
da esquerda para direita. A precedência dos operadores é apresentada na Tabela 9-4.
not ! 1
and && 2
or || 3
Tabela 9-4 - Precedência dos operadores lógicos
Primeiramente executa-se o operador “!” (not), posteriormente executa-se os operadores “&&” (and)
da esquerda para direita e por último executa-se o operador “||” (or). A regra de precedência e
associatividade é apresentada Figura 9.25.
245
Figura 9.25 - Precedência dos operadores lógicos e associatividade.
’
Exemplo prático
Copie o código da Figura 9.26 - Precedência dos operadores lógicos., insira um breakpoint na linha
10 e debug o código. Primeiramente executa-se o operador “!” (not), posteriormente executa-se os
operadores “&&” (and) da esquerda para direita e por último executa-se o operador “||” (or). Observe
o resultado apresentado na janela do debug.
Figura 9.26 - Precedência dos operadores lógicos.
246
10 OPERADORES
DE INCREMENTO
E DECREMENTO
247
10.1 Introdução
Operadores de incremento e decremento, somam ou subtraem 1 a variável, cada vez que são
aplicados. O operador de incremento é representado pelo símbolo “++” e o operador de decremento
pelo símbolo “--”.
Figura 10.1 - Operadores de incremento e decremento.
Existem três formas de fazer o incremento e decremento de uma variável, conforme apresentado na
Figura 10.2. A forma mais curta é usando os operadores de incremento e decremento. A segunda
forma é utilizando os operadores de atribuição composta seguido dos operadores “+=” ou “-=” e do
valor 1. E a última forma é usando o operador de atribuição simples, seguida do valor da variável, do
operador aritmético “+” ou “–” e do valor 1.
Figura 10.2 - Formas de fazer incremento ou decremento.
248
10.2 Prefixo e Sufixo
Os operadores de incremento e decremento podem ser prefixo ou sufixo. Operador prefixo, vem antes
da variável e sufixo vem depois da variável. A Figura 10.3 apresenta um exemplo do operador de
incremento prefixo e sufixo, a mesma regra se aplica ao operador de decremento.
Figura 10.3 - Operador de incremento prefixo e sufixo.
Se o operador for prefixo, o incremento ou decremento é efetuado antes da atribuição. Se o operador

for sufixo, a atribuição é efetuada antes do incremento ou decremento.
No exemplo da Figura 10.4 é utilizado o operador de incremento prefixado. A variável contador,

primeiro recebe o incremento e somente depois atribui seu valor a variável ponto. No fim da execução,
o valor da variável ponto e contador é 2.
Figura 10.4 - Incremento prefixado e atribuição
No exemplo da Figura 10.5 é utilizado operador de incremento sufixado. A variável contador,

primeiro atribui seu valor a variável ponto e somente depois recebe o incremento 1. No fim da
execução, o valor da variável ponto é 1 e da variável contador é 2.
249
Figura 10.5 - Incremento sufixado e atribuição.
Exemplo prático
Digite o comando “dotnet new console -n “OperadorIncrementoDecrementoSufixoPrefixo” no

terminal para criar um programa. Abra o programa no VS Code, copie o código da Figura 10.6, insira
um breakpoint na linha 14 e inicie o debug. Compare os valores exibidos no terminal com os valores
das variáveis exibido no campo do debug. Observe que os operadores de incremento e decremento
prefixos primeiramente executam o valor e somente depois recebem a atribuição de + 1 ou -1. No
entanto os sufixos, primeiro recebem a atribuição de +1 ou -1 e somente depois executam o valor.
250
Figura 10.6 - Comportamento dos operadores de decremento e incremento prefixos e sufixos
10.3 - Operadores de incremento e decremento com laço while.

A forma como são aplicados os operadores de incremento e decremento altera o comportamento do
laço. Se o operador for prefixado, o laço deverá ser escrito de forma diferente de quando sufixado,
caso a intenção seja obter o mesmo resultado. Um exemplo de um contador de 1 a 10 é apresentado
na Figura 10.7 utilizando o operador de incremento prefixado e sufixado.
251
Figura 10.7 – Comportamento do operador de incremento com laço while
Exemplo prático
Digite no terminal o comando “dotnet new console -n “OperadorIncrementoPrefixo” para criar um

programa. Abra o programa no VS Code, copie o código da Figura 10.8 e execute o comando “dotnet
run”. O programa apresenta um contador de 1 a 10, utilizando o operador de incremento prefixado.
252
Figura 10.8 - Operador de incremento com laço while.
Exemplo prático
Digite no terminal o comando “dotnet new console -n “OperadorIncrementoSufixo” para criar um

run”. O programa apresenta um contador de 1 a 10, utilizando o operador de incremento sufixado.
253
Figura 10.9 - Operador incremento sufixo com laço while.
10.4 Exercício contagem regressiva

Desenvolva um programa que mostre a contagem regressiva de 10 até 0. Utilize o operador de
decremento. O exercício resolvido é apresentado na Figura 10.10.
254
Figura 10.10 - Contagem regressiva de 10 a 0.
255
11 ESTRUTURA
DE REPETIÇÃO
FOR
256
11.1 Introdução
A instrução for é uma estrutura de repetição que permite repetir determinada ação um número de
vezes. A instrução for geralmente é chamada de laço for ou loop for. Já aprendemos como funciona
a sentença while, que também permite repetir uma determinada ação um número de vezes. Você deve
estar se perguntando: por que existe mais uma estrutura de repetição? Calma, cada estrutura é mais
apropriada para determinado problema.
O laço for é mais adequado para controlar laços controlados por contador, que são executados em um
intervalo específico. Dentro do laço for é possível iniciar o contador, condição da iteração e ainda
atualizar a variável contadora.
A sentença for executa um bloco de instruções um número fixo de vezes. O laço for se diferencia do
laço while porque as operações de controle do laço se situam em um só lugar, no cabeçalho da
instrução. Um exemplo da estrutura do laço for é apresentado na Figura 11.1
Figura 11.1 - Estrutura da instrução for
Palavra-chave: Determina que é um laço for;

Inicializa contador: Inicia a variável que faz o controle do laço;
Expressão booleana: Condição que que determina a quantidade de interações do laço, geralmente é
uma expressão relacional.
Atualiza o contador: Incrementa ou decrementa a variável de controle do laço.
Corpo: Conjunto de instruções que são executadas a cada iteração do laço.
257
A variável de controle pode ser inicializada com qualquer valor e pode ser atualizada pelos operadores
de incremento e decremento, atribuição composta ou uma expressão utilizando o operador de
atribuição simples.
Figura 11.2 - Atualização da variável contadora da instrução for
11.2 Formato Ascendente e Descendente

Existem duas maneiras de implementar a instrução for: formato ascendente, no qual a variável de
controle é incrementada e, formato descendente, no qual a variável de controle é decrementada.
Figura 11.3 - Instrução ascendente e descendente.
258
Exemplo prático
Digite no terminal o comando “dotnet new console -n “InstrucaoForAscendente” para criar um

run” para iniciar o programa. A variável de controle “cont” é do tipo inteiro e inicia com o valor 1. A
quantidade limite de iterações é 10. A variável de controle é atualizada com o operador de incremento.
O laço executa a instrução Console.WriteLine(cont) uma vez para cada iteração. Observe o resultado
apresentado no terminal.
Figura 11.4 - Instrução for ascendente.
259
Exemplo prático
Digite no terminal o comando “dotnet new console -n “InstrucaoForDescendente” para criar um

comando “dotnet run”. A variável de controle “cont” inicia com o valor 10 e será executada até atingir
o valor 1. A variável contadora é atualizada pelo operador de decremento. Observe o resultado
apresentado no terminal.
Figura 11.5 - Instrução for descendente
260
11.3 Intervalos diferentes
Os intervalos de incremento e decremento da variável de controle do laço podem ser qualquer valor
e não necessariamente sempre 1. Por exemplo, pode ser 5, 10, 20, -4 ou qualquer outro intervalo.
Exemplo prático
Digite no terminal o comando “dotnet new console -n “InstrucaoForIntervaloDiferente” para criar um

programa. Abra o programa no VS Code, copie o código da Figura 11.6 e inicie o programa com o
comando “dotnet run”. A variável de controle “cont” inicia com o valor 0, o laço será executado até
a variável “cont” atingir o valor 50. A variável de controle “cont” é atualizada pelo operador de
atribuição composta. Observe o resultado gerado no terminal.
Figura 11.6 - Instrução intervalos diferentes.
261
11.4 Laços aninhados
Um laço for pode possuir laços aninhados ou pode estar aninhado a outro laço. Por exemplo, um laço
for pode estar dentro de um laço while ou dentro de outro laço for, conforme apresentado na Figura
11.7.
Figura 11.7 - Laços aninhados.
Para cada iteração do laço externo, o laço interno é executado até que a condição de controle seja
falsa. No exemplo da Figura 11.8, a cada iteração do laço externo o laço interno é iterado 10 vezes.
O total de iterações do laço externo será 5 e do laço interno será 50 (5 x 10).
Figura 11.8 - Iterações dos laços aninhados
262
Exemplo prático laços aninhados
Digite no terminal o comando “dotnet new console -n “InstrucaoForLacoAninhado”. Abra o

programa no VS Code, copie o código da Figura 11.9 e inicie o programa com o comando “dotnet
run”. O laço interno executa 10 iterações para cada iteração do laço externo. Observe resultado gerado
no terminal.
Figura 11.9 - Iterações em laços aninhados.
263
11.5 Escopo de bloco
A instrução for também é um bloco, as regras de escopo de bloco devem ser aplicadas. As variáveis
declaradas no cabeçalho e no corpo não podem ser acessadas por métodos externos. No exemplo da
Figura 11.10 o método Main (bloco externo) tenta acessar a variável “contador”. Um erro é gerado,
a variável “contador” pertence ao bloco interno, não pode ser acessa pelo bloco externo.
Figura 11.10 - Escopo de bloco acesso a propriedade interna.
Blocos internos podem acessar as variáveis do bloco externo. No exemplo da Figura 11.11, o bloco
for (bloco interno) acessa a variável “numero” do método Main (bloco externo).
Figura 11.11 - Escopo de bloco acesso a propriedade externa.
264
Na Figura 11.12, a instrução for (bloco interno) acessa a variável “i” da instrução for (bloco externo).
Figura 11.12 - Escopo de bloco laço for aninhado acesso a variável externa.
Na Figura 11.13, a variável “j” pertencente a instrução for (bloco interno) não pode ser acessada pela
instrução for (bloco externo).
Figura 11.13 - Escopo de bloco laço for aninhado acesso a variável interna.
265
12 ARRAY
UNIDIMENSIONAL
266
13.1 Introdução
Quando queremos guardar diversas informações, podemos fazer uso de arrays. Um array é uma
estrutura de dados que consegue armazenar uma série de dados ordenados, chamados elementos, que
podem ser localizados pelo índice. São úteis, quando trabalhamos com coleções de dados que
possuem um tamanho previamente definido. Um array unidimensional geralmente é chamado de
vetor.
Um array armazena muitos elementos do mesmo tipo, tais como vinte números inteiros, cinquenta
números de ponto flutuante ou quinze caracteres. Você pode definir qualquer tamanho e qualquer tipo
para um array. Um array pode conter, o nome dos alunos de uma sala, a temperatura de cada dia de
um mês, operações bancárias de um cliente e muito mais. Um array deve ser usado quando você
precisa armazenar um conjunto de informações do mesmo tipo.
Pense em arrays como um conjunto de variáveis do mesmo tipo e cada variável tem uma posição
dentro desse conjunto. Fazendo uma analogia entre um array e um trem, pense que o array é a
locomotiva e as variáveis são os vagões. A locomotiva para ser identificada precisa de um nome,
neste caso é o nome do array. Os vagões são identificados através de números inteiros, que
representam a posição de cada vagão, neste caso é a posição da variável no array. A numeração desses
vagões, começam em zero e vai até a quantidade de vagão menos um. Observe a analogia representada
na Figura 13.1.
Figura 13.1 - Analogia array e trem.
267
13.2 Declaração de array
Assim como qualquer tipo de variável, um array também deve ser declarado antes de ser utilizado.
Um array é declarado de forma similar a uma variável, exceto que deve indicar o tamanho do array.
Para declarar um array, informe o tipo, abra e feche colchetes e por fim digite o nome. Por convenção
nomes de array podem ser escritos com a última palavra no plural. Um exemplo de declaração de
array é apresentado na Figura 13.2.
Figura 13.2 - Declaração de array.
Exemplo prático
Digite no terminal o comando “dotnet new console -n “ArrayDeclaracao” para criar um programa.
Abra o programa no VS Code, copie o código da Figura 13.3 e inicie o debug. Observe que o array
não possui um tamanho definido e seu valor é null. O array precisa ser instanciado para que possa ser
utilizado.
268
Figura 13.3 - Declaração de array.
Instanciando um array
O array precisa ser instanciado para ser atribuído um valor. Instanciar é o processo de criar, de
concretizar algo que está declarado, mas não criado. Quando instanciamos um array montamos o
array na memória.
O processo de instanciar é necessário em tipos de dados customizados. Os tipos de dados

customizados são criados a partir dos tipos de dados primitivos. Por exemplo, um array é uma
estrutura de dado customizada que possui múltiplos elementos de um tipo.
Para instanciar um array devemos inserir o operador de atribuição “=” seguido da palavra-chave
“new”, tipo do array e entre colchetes o tamanho do array.
269
Figura 13.4 –Declarando e Instanciando array
Exemplo prático
Copie o código da Figura 13.5, insira um breakpoint na linha 11 e inicie o debug. Observe a diferença
entre o array alunoNotas e a variável nota. No painel de debug o array é null, por enquanto a variável
nota possui o valor padrão zero. Isto acontece, porque os arrays precisam ser instanciados, por
enquanto, dados de tipos primitivos não precisam.
Figura 13.5 - Array é null até ser instanciado.
270
Copie o código da Figura 13.6 e inicie o debug. Observe que o array foi instanciado, o valor padrão
zero é atribuído aos elementos do array.
Figura 13.6 - Array do tipo int instanciando recebe o valor padrão zero.
Atribuição de valor
É possível atribuir valores ao arrays no momento da declaração, assim como é feito com as variáveis.
Para atribuir valores ao array, insira o valor entre chaves separados por vírgula. Um exemplo é
apresentado na Figura 13.7
Figura 13.7 - Atribuindo valores iniciais a array
Cada valor separado por vírgula, consiste em um elemento do array. Os elementos são inseridos no
array, pela ordem que são declarados entre as chaves, conforme apresentado na Figura 13.8.
271
Figura 13.8 - Posição dos elementos atribuídos ao array.
Exemplo prático
Copie o código da Figura 13.9, insira um breakpoint na linha 10 e inicie o debug. Observe no painel
de debug, que todos elementos do array foram preenchidos na ordem dos valores inseridos na
inicialização.
Figura 13.9 - Atribuindo valores iniciais a um array
Sintaxe curta
Existe uma sintaxe mais curta, que pode ser usada quando os valores do array são atribuídos na
declaração. Nesta sintaxe, não é necessário inserir a palavra reservada new, tipo e tamanho. O
tamanho do array é determinado pela quantidade de elementos entre chaves. Observe a sintaxe na
Figura 13.10.
272
Figura 13.10 – Diferença entre sintaxe normal e curta de declaração de array.
Exemplo prático
Copie o código da Figura 13.11, insira um breakpoint na linha 10 e inicie o debug. O código é
executado com sucesso.
Figura 13.11 - Declaração de array com sintaxe curta.
Tipos de dados
Os valores são atribuídos de forma diferente, conforme o tipo de dado. As mesmas regras de
atribuição aplicadas em atribuições de variáveis, também são aplicadas nos arrays. Por exemplo, para
atribuir um valor do tipo float é necessário utilizar a letra f no fim do número, aspas simples para
caractere, aspas duplas para string, etc.
273
Figura 13.12 - Tipos de dados em arrays
Exemplo prático
Copie o código da Figura 13.13, insira um breakpoint na linha 13 e inicie o debug. Observe os arrays
no painel de debug e os respectivos arrays no código.
Figura 13.13 - Array e tipos de dados.
13.3 Atribuição por índice

A atribuição pode ser realizada diretamente pelo índice do array. Antes de atribuir um valor pelo
índice, o array precisa estar instanciado.
274
Figura 13.14 - Atribuição por índice do array.
Exemplo prático
Copie o código Figura 13.15, insira um breakpoint na linha 15 e inicie o debug. Todos os elementos
recebem os valores atribuído de acordo com o índice, observe o painel do debug.
Figura 13.15 - Atribuição por índice.
275
13.4 Acessando elementos por índice
Para obter o valor de um elemento do array, deve-se utilizar o índice do elemento. O índice se refere
a posição do elemento dentro do array, pense no índice como um endereço. Um elemento é localizado
pelo nome do array e índice, conforme apresentado na Figura 13.16.
Figura 13.16 - Obtendo valores dos elementos pelo índice do array.
Em alguns casos, podemos usar as informações de diferentes arrays e juntar essas informações. Desde
que, essas informações estejam alinhadas corretamente pelo índice. Por exemplo, no array
alunoNomes no índice 4 está o Igor e a nota referente ao Igor está no índice 4 do array alunoNotas.
Figura 13.17 – Arrays alinhados corretamente.
Exemplo prático
Copie o código e execute o programa com o comando dotnet run. Observe no terminal que a nota
correspondente ao aluno Igor foi concatenada corretamente.
276
Figura 13.18 - Obtendo simultaneamente dados dos Arrays aluno Notas e alunoNomes
13.5 Atribuição com laço.

Pode-se atribuir valores a um array utilizando um laço for, while ou do-while. Este costuma ser o
sistema mais utilizado. Por exemplo, para inicializar todos os valores do array com o valor 10, pode-
se utilizar os laços apresentado na Figura 13.19.
Figura 13.19 - Atribuição de arrays com laço.
Exemplo prático
Digite no terminal o comando “dotnet new console -n “ArrayAtribuicaoLaco” para criar um

programa. Abra o programa no VS Code, copie o código da Figura 13.3, insira um breakpoint na
linha 11 e inicie o debug. Observe o debug passo a passo.
277
Figura 13.20 - Atribuição de array com laço for
Copie o programa da Figura 13.21, insira um breakpoint na linha 12 e inicie o debug. Observe o
debug do programa passo a passo.
Figura 13.21 - Atribuição de array com laço while
13.6 Acessando elementos com laço

O acesso aos elementos de um array podem ser realizados através dos laços for, while ou do-while.
Por exemplo, você precisa mostrar uma lista das notas dos alunos, para acessar todos elementos é
necessário usar um laço.
278
Exemplo prático
Digite no terminal o comando “dotnet new console -n “ArrayAcessandoElementoLaco” para criar um

programa. Abra o programa no VS Code, copie o código da Figura 13.22 e execute o programa com
o comando “dotnet run”.
Figura 13.22 - Acessando elementos com laço while.
279
Copie o código da Figura 13.23 e execute o programa com o comando “dotnet run”. O laço for itera
o array alunoNotas, este é o tipo de laço mais indicado para iterar arrays.
Figura 13.23 - Acessando elementos com laço for.
13.7 Exercício Palavra Inversa

Desenvolva um programa que receba uma palavra escrita pelo usuário e apresente a mesma palavra
na ordem inversa. Utilize a função ToCharArray() para converter a string em um array do tipo char.
O exercício resolvido é apresentado na Figura 13.24.
280
Figura 13.24 - Exercício resolvido palavra inversa
13.8 Instrução foreach

A sentença foreach permite iterar um array de forma mais simples que os laços for, while
e do-while. A iteração inicia no índice 0 e a cada iteração avança um índice até o último
elemento. Assim, todos os elementos do array são visitados.
O foreach é uma estrutura mais simples para iterar um array, é apropriado para obter todos
elementos de um array. Não deve ser utilizado para atribuir um valor ao array, controlar
diretamente o índice ou manipular os dados de mais de um array simultaneamente . A
estrutura do array é apresentada na Figura 13.25.Figura 13.25
281
Figura 13.25 - Estrutura da instrução foreach.
Palavra-chave foreach: determina que é um laço foreach.

Tipo da variável: tipo da variável que recebe o valor de cada elemento do array .
Variável: nome da variável que recebe o valor de cada elemento do array.
Palavra-chave in: palavra-chave in obtém o valor do elemento do array e atribui a variável .
array: é o array que será iterado.
Exemplo prático
Digite no terminal o comando “dotnet new console -n “ArrayForeach” para criar um programa. Abra
debug. A cada iteração a variável nota recebe um elemento do array AlunoNotas . Observe
o resultado no terminal.
282
Figura 13.26 - Array Foreach.
Se for necessário controlar dois arrays ao mesmo tempo, por exemplo, nome dos alunos
e nota, não tem como utilizar o foreach . Neste caso, o laço for é o mais indicado. Um
exemplo é apresentado na Figura 13.27.
Figura 13.27 - Iteração de dois arrays com laço for.
283
Se tentar atribuir um valor a uma variável de iteração foreach, um erro será retornado. Observe o
exemplo da Figura 13.28
Figura 13.28 - Não é possível atribuir um valor a uma variável de iteração foreach.
13.9 Exercício Lista de Presença

Desenvolva um programa que permita o professor, fazer o controle da lista de presença dos alunos de
uma sala de aula. O programa deve apresentar o nome do aluno e, solicitar ao professor que informe
se o aluno está presente ou ausente. No fim da execução do programa, uma lista com o nome dos
alunos e a respectiva situação presente ou ausente deve ser apresentada. O total de alunos ausentes e
presentes também deve ser apresentado. Crie um array para representar a lista de alunos, insira 7
nomes aleatórios dentro do array. O código resolvido do exercício é apresentado na Figura 13.29, a
execução do programa é apresentado na Figura 13.30 e o resultado da lista de presença é apresentado
Figura 13.31.
284
Figura 13.29 - Exercício lista de presença resolvido.
285
Figura 13.30 - Lista de chamada do exercício lista de presença.
Figura 13.31 - Resultado do exercício lista de presença.
286
14 Métodos
287
14.1 Introdução
A maioria dos programas de computador resolvem problemas reais, esses programas são maiores do
que os programas apresentados até agora neste livro. Em todos exemplos apresentados, escrevemos
todo o nosso código dentro do método Main, isso não é aconselhável. Imagine um programa real
escrito dessa forma, seria impossível de mantê-lo. A experiência tem mostrado que a melhor maneira
de desenvolver e manter um grande programa, é construí-lo a partir de módulos, que são pequenas
partes de código. Em C#, os módulos são chamados de métodos ou classes, neste capítulo, falaremos
sobre métodos, que também são conhecidos pelo termo função. O nome método geralmente é usado
em programação orientada a objetos, enquanto o termo função é usado na programação procedural.
Como o C# é uma linguagem de programação orientada a objetos, devemos usar o termo método.
Até agora, usamos alguns métodos, que nos auxiliaram a desenvolver nossos pequenos programas.
Por exemplo, o método “WriteLine()” é um método da biblioteca do C#, usamos várias vezes para
escrever no console alguma mensagem ao usuário. Quando você chama um método como este, muito
código é executado, mas não precisamos conhecê-lo, porque as informações são abstraídas pelo
método. Imagine, toda vez que você precisar escrever no console, ter que escrever um monte de
código complexo, se preocupando com coisas como Fluxos de E/S de terminal, buffer de tela e
terminal, suporte Unicode do terminal e mais um monte de coisas. Por isto podemos usar os diversos
métodos que fazem parte da biblioteca do C#, ou escrever nossos próprios métodos.
O principal objetivo de um método é tornar um procedimento específico e independente do trecho

principal de código, funcionando como um miniprograma dentro do programa. Essa abordagem
permite melhorar a organização e reusabilidade. Simplesmente você pode chamar um conjunto de
instruções de qualquer parte de um programa, sem se preocupar com a complexidade do código.
14.2 Como funciona

Um método deve ser criado para exercer uma função específica. Um exemplo seria considerar um
programa de calculadora. Cada operação (soma, subtração, divisão, multiplicação) da calculadora,
pode ser um método. Desta forma, é possível reutilizar o código quantas vezes for necessário, sem ter
que escrever o código novamente. Os métodos são identificados por um nome e podem ser chamados
sempre que necessário. A Figura 14.1 apresenta as operações da calculadora através de métodos.
288
Figura 14.1 - Métodos da calculadora
Para invocar um dos métodos, basta informar o nome, seguido dos argumentos e coletar o valor de
retorno se houver. A Figura 14.2 apresenta o código para invocar os métodos e coletar o retorno do
método.
Figura 14.2 - Invocando métodos da calculadora.
289
As variáveis entre parênteses do método são chamadas de parâmetros e, os valores dentro dos
parênteses na invocação do método são chamados de argumentos.
Figura 14.3 - Parâmetros e argumentos do método.
Os argumentos inseridos entre os parênteses na invocação do método, são recebidos pelos parâmetros
do método. Os argumentos devem ser passados na ordem dos parâmetros e devem ser do mesmo tipo.
Neste exemplo, o parâmetro parcelaA recebe o valor 3 e o parâmetro parcelaB recebe o valor 8.
Figura 14.4 - Parâmetros e argumento do método.
Quando um método é invocado, um valor pode ser retornado para instrução que o invocou. Este valor
pode ser armazenado em uma variável. No exemplo da Figura 14.5, o método Somar é invocado e
retorna uma valor, que é armazenado na variável resultado.
290
Figura 14.5 - Retorno do método.
14.3 Estrutura
A estrutura padrão do método, possui: tipo de retorno, nome, lista de parâmetros, corpo, palavra-
chave return e valor do retorno. A Figura 14.6 apresenta a estrutura padrão.
Figura 14.6 - Estrutura do método.
Os aspectos mais importantes são detalhados a seguir:
▪ Tipo de retorno: é o tipo de dado retornado pelo método ao invocador. Deve ser inserido
antes do nome da função;
291
▪ Nome: é o identificador do método, que deve corresponder a tarefa que o método faz. O
método é invocado pelo nome;
▪ Lista de parâmetros: é uma lista de variáveis, separadas por vírgula e são inseridas entre
parênteses. Ao invocar o método, os argumentos devem ser inseridos na mesma ordem dos
parâmetros e também devem ser do mesmo tipo dos parâmetros;
▪ Corpo: são as instruções inseridas entre as chaves de abertura e fechamento;
▪ Palavra-chave return: deve ser inserida antes do valor a ser retornado pelo método.
O método precisa ser invocado para ser executado. A estrutura padrão para invocar um método, possui
o nome do método, seguido de uma lista de argumentos separados por vírgula entre parênteses. A
estrutura é apresentada na Figura 14.7.
Figura 14.7 - Estrutura para invocar o método.
14.4 Invocando método

Para executar um método, é necessário invocá-lo (chamá-lo). Quando um método é invocado a
execução do programa redirecionará o controle do programa para o método invocado. Após o
programa executar as instruções do método, retorna ao local que o invocou. Caso o método retorne
um valor, poderá ser guardado em uma variável ou inserido numa expressão. As etapas realizadas
pelos métodos são apresentadas na Figura 14.8.
292
Figura 14.8 - Invocando método.
Exemplo Prático
Crie um programa, digite no terminal o comando “dotnet new console -n “MetodoSomar” para criar
um programa. Abra o programa no VS Code. Copie o código da Figura 14.9, insira um breakpoint na
linha 9 e inicie o debug. Os parâmetros do método recebem os valores passados como argumento na
invocação. No fim da execução do método, na linha 20, a variável soma já possui o resultado para
retornar. Quando o programa atinge o fim do método retorna o valor a quem o invocou.
293
Figura 14.9 - Método Somar
294
14.5 Definindo um método
Antes de escrever um método, é necessário defini-lo através de um conjunto de etapas, conforme
Figura 14.10 - Definindo um método
A descrição de cada etapa envolvida no processo, são apresentadas a seguir:

1. Identifique o problema que o método deve resolver, isso ajuda a identificar o propósito do
método;
2. Defina um único propósito, métodos de proposito único são mais fáceis de escrever, testar,
modificar e manter;
3. Especifique as entradas e saídas, quais são os dados que o método precisa, quais dados o
método deve retornar;
4. Verificar se os dados recebidos precisam estar dentro de um intervalo de valor.
5. Considere os erros que podem ocorrer e como tratá-los.
Neste problema vamos ilustrar o desenvolvimento de uma calculadora, porém vamos nos limitar
apenas na operação de divisão para simplificar o exemplo. A seguir são definidas as etapas de
definição do método:
• Identificação do problema: Operação de divisão de uma calculadora

• Propósito: Fazer uma operação de divisão entre dois números.
• Dados de entrada: Dividendo e divisor.
• Dado de saída: Resultado da operação de divisão realizado com os dados de entrada.
• Intervalo dados de entrada: Deve ser diferente de zero, pode ser qualquer número abaixo
ou acima de zero.
295
• Erros: Divisor igual a 0 gera um erro.
O método apresentado na Figura 14.11 foi codificado seguindo a metodologia de definição de método.
A instrução if verifica se o valor do divisor é igual a zero, essa verificação é obrigatória porque
nenhum número pode ser dividido por zero. Se o divisor for igual a zero uma exceção será lançada
no sistema interrompendo o fluxo.
Figura 14.11 - Método codificado através das etapas de definição.
Exemplo prático
Digite no terminal o comando “dotnet new console -n “MetodoDividir” para criar um programa. Abra
debug. Observe que o divisor é igual a zero e por este motivo, uma exceção é lançada informando
que o argumento especificado está fora do intervalo de valores válidos.
296
Figura 14.12 – Parâmetro fora do intervalo.
14.6 Escopo de bloco

O escopo de bloco também é válido para os métodos. Os parâmetros e as variáveis declaradas dentro
do método, são considerados variáveis locais. Variáveis locais possuem duas características
intrínseca, inacessíveis por métodos externo e alocação de memória em tempo de execução do
método.
Inacessíveis por métodos externos
Apenas o método que a define sabe de sua existência, não são acessíveis por nenhum outro método.
Só é possível alterar o valor de uma variável local, no interior do método na qual foi declarada.
Um exemplo de escopo restrito de variável local é apresentado na Figura 14.13. O método Somar
tenta utilizar as variáveis parcelaA e parcelaB do método Main, mas o compilador não reconhece.
297
Figura 14.13 - Variáveis locais são inacessíveis por métodos externo.
O exemplo prático
Abra o programa MetodoSomar no VS Code. Copie o código da Figura 14.14, insira um breakpoint
na linha 9 e digite o comando “dotnet run” para iniciar o programa. Um erro é gerado, o compilador
não reconhece parcelaA e parcelaB, porque não estão definidas no método Somar. As variáveis
parcelaA e parcelaB só existem no método Main e só podem ser acessadas dentro do método a qual
pertencem.
298
Figura 14.14 - Variáveis possuem escopo restrito
Variáveis duplicadas no mesmo escopo

Variáveis e parâmetros não podem ser declaradas com o mesmo nome dentro do mesmo método. A
Figura 14.15 apresenta um exemplo.
299
Figura 14.15 - Variáveis duplicadas.
Exemplo prático
Abra o programa MetodoSomar no VS Code, copie o código da Figura 14.16 e digite o comando
“dotnet run” no terminal para iniciar o programa. Observe que um erro é gerado informando que a
variável já está declarada no escopo.
Figura 14.16 - Variáveis duplicadas
300
Variáveis duplicadas em escopos diferentes
As variáveis podem ter o mesmo nome, desde que sejam declaradas em métodos diferentes. Variáveis
declaradas em métodos diferentes possuem escopos diferentes. Um exemplo é apresentado na Figura
4.17.
Figura 14.17 – Variáveis com mesmo nome em métodos diferentes.
Abra o programa MetodoSomar no VS Code, copie o código da Figura 14.18 e digite o comando
“dotnet run” no terminal para iniciar o programa. Observe que as variáveis do método Main e do
método Somar possuem o mesmo nome e nenhum erro é gerado.
301
Figura 14.18 - Variáveis duplicas em métodos diferentes.
Alocação memória
Variáveis locais existem na memória somente enquanto o método está sendo executado. O espaço na
memória, só é alocado no momento da execução do método. Quando o método termina, as variáveis
locais deixam de existir. Este comportamento torna as variáveis locais performáticas, porque não
ocupam espaço na memória durante todo o programa.
No exemplo apresentado na Figura 14.19. O método Main é executado, as variáveis, valorA, valorB
e resultado são alocadas na memória. Por enquanto o método Somar não é executado, as variáveis
parcelaA, parcelaB e soma não existem na memória. No momento em que o método Somar é
invocado, as variáveis parcelaA, parcelaB e soma são alocadas na memória. As variáveis do método
Main continuam existindo na memória durante a execução do método somar, porém, não são
acessíveis pelo método Somar. Após o término do método Somar, as variáveis parcelaA, parcelaB e
soma deixam de existir na memória.
302
Figura 14.19 – Variáveis locais e memória.
Exemplo prático
Abra o programa MetodoSomar no VS Code, copie o código da Figura 14.20, insira um breakpoint
na linha 9 e inicie o debug.. Observe que durante o debug, o VS Code mostra apenas as variáveis que
fazem parte do método que está em execução. Quando a execução está no método Main, as variáveis
do método Somar não são apresentadas no painel de variáveis do debug e o inverso também se aplica.
Quando o método Somar está em execução, o debug não apresenta as variáveis do método Main. Mas
as variáveis do método Main continuam na memória, apenas estão inacessíveis pelo método Somar,
por este motivo não são apresentadas. As variáveis do método Main continuam na memória, porque
o método Main está aguardando o retorno do método Somar.
303
Figura 14.20 - Métodos e alocação de memória.
14.7 Exercício Vogal ‘a’
Desenvolva um programa que solicite ao usuário uma palavra ou frase e mostre ao usuário se a vogal
“a” existe ou não. O exercício resolvido é apresentado na Figura 14.21.
304
Figura 14.21 - Exercício vogal 'a'
305
14.8 Exercício Quantidade de Vogais
Desenvolva um programa que solicite ao usuário uma palavra ou frase e mostre ao usuário a
quantidade total de vogais. Utilize métodos, o método Main deve chamar o método responsável por
contar as vogais, que deverá retornar o resultado ao método Main. Antes de contar as vogais,
transforme as letras para minúsculo, ficará mais fácil de contar. O exercício resolvido é apresentado
na Figura 14.22.
Figura 14.22 - Quantidade total de vogais.
306
Copy protected with Online-PDF-No-Copy.com

Logica de Programacao e Algoritmos Com C Sharp Ed1 PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Logica de Programacao e Algoritmos Com C Sharp Ed1 PDF

Enviado por

Direitos autorais:

Formatos disponíveis

1

é graduado em Ciência da Computação pela Universidade do Vale do Itajaí – UNIVALI. É

Todos os programas de computadores são construídos a partir

Numa receita de bolo de milho, temos várias instruções.

Receita - Bolo de Milho:

• Adicionar 1 lata de milho verde com água e tudo;

Receita - Bolo de Milho:

Este conjunto de instruções é apenas para fazer um

A lógica de Programação é a lógica utilizada para desenvolver um programa de computador. Está

Módulo - Conta do cliente:

Pseudocódigo não é só pra iniciantes, muitas pessoas cometem esse erro.

A melhor maneira de desenvolver um programa, é se

Mesmo que você seja um programador experiente e nunca

Para escrever um pseudocódigo corretamente é necessário satisfazer todas as características

• Ser preciso: deve indicar a ordem de realização de cada passo;

• Examinar a ficha do cliente;

• Se o cliente é idôneo a fábrica aceita o pedido, caso contrário, recusa o pedido.

A função do computador é executar os softwares desenvolvidos

Existem várias linguagens de programação, algumas são usadas

A linguagem de programação é um método

Linguagens como C#, JavaScript, Python, Ruby,

A linguagem HTML (inglês HyperText Markup Language - português Linguagem de Marcação de

1.4 Editores de Texto e IDEs

Os editores de texto permitem personalizar tipo e

Além da personalização estética, os editores de texto

Figura 1.2 - Código erro de sintaxe

Você não deve perder tempo pensando se usa um Editor

Instalação do Visual Studio Code no Windows

Para fazer o download do Visual Studio Code acesse https://code.visualstudio.com/download e

Na pasta download clique duas vezes no ícone VSCodeUserSetupx64-1.44.2, conforme apresentado

Figura 1.4 - Ícone VS Code

Figura 1.6- Janela de aceitação de termos

Figura 1.8 - Local do atalho

Figura 1.9 - Tarefas adicionais

Figura 1.11- Conclusão de instalação

Figura 1.12 - Abrindo VS Code.

Instalação Visual Studio Code no Mac

Para fazer o download do Visual Studio Code acesse https://code.visualstudio.com/download e

Vá até a pasta download e descompacte o arquivo VSCode-darwin-stable.zip. Conforme apresentado

Figura 1.14- Arquivo de download compactado

Figura 1.15 - ícone de instalação e pasta aplicativos

Figura 1.16 - Pasta Aplicativos com VS Code

Figura 1.17 - Launchpad

Figura 1.18 - Launchpad aplicativos.

Figura 1.19 - Diferenças entre fontes

Figura 1.22 - Diferença entre caracteres

Figura 1.24 - Letra Menlo

Figura 1.25 - Configuração de fonte no VS Code

1.6 Extensões para Visual Studio Code

Figura 1.27 - IntelliSense erro de sintaxe

Instalando Extensões no Visual Studio Code

Figura 1.29 - Pesquisa de extensões

Figura 1.31 - Instalação do Bracket

Figura 1.32- Instalação do Bracket

Configurando Auto Save no VS Code

Figura 1.34 - Configurando auto save

1.7 Net Core Runtime e .Net Core SDK

Figura 1.35 - Status do .Net Core

Figura 1.36 - Ciclo de vida

Runtime: é um componente da máquina virtual da plataforma .Net da Microsoft para gerenciar a

SDK: é um Kit de Desenvolvimento de Software para plataforma .Net da Microsoft.

F#: é uma linguagem de programação multiparadigma produzida pela Microsoft direcionada a

Digite no seu navegador https://dotnet.microsoft.com/download e selecione a opção Windows no