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

Prévia do material em texto

1 
 
 
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. Vocês 
deram um sentido especial a minha vida, me proporcionando grandes momentos de alegria. 
 4 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
As únicas limitações sã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.2 Precedência dos operadores................................................................................... 184 
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.6 Precedência dos operadores................................................................................... 244 
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 
 
 15 
 
 
 
 
1 CONCEITOS 
BÁSICOS 
 
 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 desenvolverum 
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 
apresentado na Figura 1.33. 
 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 visualizaras 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 
apresentado na Figura 1.38. 
 
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 
apresentado na Figura 1.41. 
 
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, 
conforme apresentado na Figura 1.52. 
 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 Files\PowerShell\. 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, 
conforme apresentado na Figura 1.63. 
 
 
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 
conforme apresentado na Figura 1.66. 
 
 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, 
conforme apresentado na Figura 1.78. 
 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óriopasta1, 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 
apresentado na Figura 1.86. 
 
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, 
conforme apresentado na Figura 1.88. 
 
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