logica-de-programacao-e-algoritmos-com-c-sharp-ed1-pdf.pdf

Lógica de
Programação e
Algoritmos
com C#
Jackson Camara

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

4
As únicas limitações são aquelas que estabelecemos em nossa mente.
Napoleon Hill.

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

6
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!

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

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

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

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

11
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

12
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

13
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

14
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

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

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

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

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

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

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

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

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

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

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

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

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

28
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

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

30
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

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

32
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

33
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

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

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

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

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

38
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

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

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

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

42
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

43
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

44
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

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

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

47
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

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

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

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

51
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

52
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

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

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

55
Figura 1.51 - Download PowerShell
Clique duas vezes no arquivo que você fez o download. Clique em Install para iniciar a instalação,

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

57
Figura 1.53 - Prosseguir com a instalação PowerShell
O PowerShell será instalado na pasta c:Program FilesPowerShell. Mantenha o local padrão, clique
no botão Next conforme apresentado na Figura 1.54.

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

59
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

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

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

62
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

63
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

64
Figura 1.66 - Abrindo preferências do sistema
Em Preferências do Sistema selecione Segurança e Privacidade conforme apresentado na Figura
1.67.

65
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

66
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

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

68
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

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

70
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,

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

72
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

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

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

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

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

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

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

79
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!!!

80
Figura 1.87 - Executando o programa

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

82
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

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

84
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,

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

86
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,

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

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

89
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

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

91
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

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

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

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

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

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

97
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

98
2 LINGUAGENS
DE
PROGRAMAÇÃO

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

100
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

101
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
genérico)
value var
when (condição de filtro)
where (restrição de tipo
genérico)
where (cláusula de
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.

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

103
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

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

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

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

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

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

logica-de-programacao-e-algoritmos-com-c-sharp-ed1-pdf.pdf

logica-de-programacao-e-algoritmos-com-c-sharp-ed1-pdf.pdf

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Semelhante a logica-de-programacao-e-algoritmos-com-c-sharp-ed1-pdf.pdf

Semelhante a logica-de-programacao-e-algoritmos-com-c-sharp-ed1-pdf.pdf (20)

logica-de-programacao-e-algoritmos-com-c-sharp-ed1-pdf.pdf