Programação de Computadores C (1)

Prévia do material em texto

Programação de Computadores C#
AT 1
José Augusto N. G. Manzano
Programação de Computadores C#
1ª Edição
2 3Programação de Computadores C#
Dados Internacionais de Catalogação na Publicação (CIP) 
(Câmara Brasileira do Livro, SP, Brasil)
Manzano, José Augusto N. G.
Programação de computadores C# / José Augusto N. G. Manzano. -- São Paulo : Érica, 2014.
Bibliografia
ISBN 978-85-365-0943-3
1. C# (Linguagem de programação para computadores)
I. Título.
14-02404 CDD-005.268
Índices para catálogo sistemático: 
1. C# : Linguagem de computador : Processamento de dados 005.268
Copyright © 2014 da Editora Érica Ltda.
Todos os direitos reservados. Nenhuma parte desta publicação poderá ser reproduzida por qualquer meio ou forma sem prévia autorização 
da Editora Érica. A violação dos direitos autorais é crime estabelecido na Lei nº 9.610/98 e punido pelo Artigo 184 do Código Penal.
Coordenação Editorial: Rosana Arruda da Silva 
Capa: Maurício S. de França
Edição de Texto: Beatriz M. Carneiro, Silvia Campos
Preparação e Revisão de Texto: Clara Diament
Produção Editorial: Adriana Aguiar Santoro, Alline Bullara, Dalete Oliveira, Graziele Liborni, 
Laudemir Marinho dos Santos, Rosana Aparecida Alves dos Santos, Rosemeire Cavalheiro
Editoração: ERJ Composição Editorial
Produção Digital: Alline Bullara
O Autor e a Editora acreditam que todas as informações aqui apresentadas estão corretas e podem ser utilizadas para qualquer fim legal. 
Entretanto, não existe qualquer garantia, explícita ou implícita, de que o uso de tais informações conduzirá sempre ao resultado desejado. 
Os nomes de sites e empresas, porventura mencionados, foram utilizados apenas para ilustrar os exemplos, não tendo vínculo nenhum com 
o livro, não garantindo a sua existência nem divulgação. Eventuais erratas estarão disponíveis para download no site da Editora Érica.
Conteúdo adaptado ao Novo Acordo Ortográfico da Língua Portuguesa, em execução desde 1º de janeiro de 2009.
A ilustração de capa e algumas imagens de miolo foram retiradas de <www.shutterstock.com>, empresa com a qual se mantém contrato 
ativo na data de publicação do livro. Outras foram obtidas da Coleção MasterClips/MasterPhotos© da IMSI, 100 Rowland Way, 3rd floor 
Novato, CA 94945, USA, e do CorelDRAW X5 e X6, Corel Gallery e Corel Corporation Samples. Copyright© 2013 Editora Érica, Corel 
Corporation e seus licenciadores. Todos os direitos reservados. 
Todos os esforços foram feitos para creditar devidamente os detentores dos direitos das imagens utilizadas neste livro. Eventuais omissões 
de crédito e copyright não são intencionais e serão devidamente solucionadas nas próximas edições, bastando que seus proprietários conta-
tem os editores.
Seu cadastro é muito importante para nós
Ao preencher e remeter a ficha de cadastro constante no site da Editora Érica, você passará a receber informações sobre nossos lançamentos 
em sua área de preferência.
Conhecendo melhor os leitores e suas preferências, vamos produzir títulos que atendam suas necessidades.
Contato com o editorial: editorial@editoraerica.com.br
Editora Érica Ltda. | Uma Empresa do Grupo Saraiva
Rua São Gil, 159 - Tatuapé
CEP: 03401-030 - São Paulo - SP
Fone: (11) 2295-3066 - Fax: (11) 2097-4060
www.editoraerica.com.br
2 3
Agradecimentos
A minha esposa Sandra e minha filha Audrey.
A todas as pessoas que ajudaram direta ou indiretamente a concretizar este trabalho e também 
a melhorá-lo em relação às versões anteriores do ambiente Visual Basic.
Aos meus alunos que, com suas dúvidas, perguntas e seus questionamentos, me incentivam a 
continuar em busca do aprimoramento.
A todos os funcionários da Editora Érica, que merecem o devido respeito e carinho para que 
este trabalho chegue até o leitor.
4 5Programação de Computadores C#
Sobre o autor
Brasileiro, nascido em São Paulo-SP, a 26 de abril de 1965, é professor e mestre com licenciatu-
ra em Matemática. Atua, desde 1986, na área de Tecnologia da Informação (TI), em desenvolvimento 
de softwares e em ensino e treinamento. Participou do desenvolvimento de aplicações computacionais 
para as áreas de telecomunicação e comércio.
Na carreira docente, iniciou sua atividade em cursos livres, trabalhando mais tarde em empre-
sas de treinamento e lecionando no ensino técnico e superior. Atuou em empresas da área, como: 
ABAK, SERVIMEC, CEBEL, SPCI, BEPE, ORIGIN e OpenClass, entre outras. Atualmente, é pro-
fessor com dedicação exclusiva do Instituto Federal de Educação, Ciência e Tecnologia de São Paulo 
(IFSP), antiga Escola Técnica Federal.
Reúne condições para ministrar componentes curriculares de Lógica de Programação (algorit-
mos), Estrutura de Dados, Microinformática, Informática, Linguagens de Programação Estruturada, 
Linguagens de Programação Orientada a Objetos, Engenharia de Software, Tópicos Avançados em 
Processamento de Dados, Sistemas de Informação, Engenharia da Informação, Arquitetura de Com-
putadores e Tecnologias Web.
Tem conhecimento em uso e aplicação das linguagens de programação, como CLASSIC 
BASIC, COMAL, Assembly, LOGO, PASCAL, FORTRAN, C, C++, JAVA, MODULA-2, STRUCTURED 
BASIC, C#, Lua, HTML, XHTML, JavaScript, VBA e ADA, é autor de mais de sessenta obras publi-
cadas, além de artigos divulgados tanto no Brasil quanto no exterior.
4 5
Sumário
Capítulo 1 - Introdução ................................................................................................ 9
1.1 Plataforma .NET .............................................................................................................................................9
1.2 Breve histórico sobre C# ..............................................................................................................................11
1.3 O ambiente de programação .......................................................................................................................12
1.4 Programação orientada a objetos ...............................................................................................................15
1.5 Programação em modo gráfico ou em modo console .............................................................................17
Agora é com você! ...............................................................................................................................................18
Capítulo 2 - Programação Sequencial ........................................................................... 19
2.1 Tipos de dados...............................................................................................................................................19
2.2 Variáveis .........................................................................................................................................................21
2.3 Constantes ......................................................................................................................................................22
2.4 Operadores aritméticos ................................................................................................................................22
2.5 Expressões aritméticas .................................................................................................................................23
2.6 Estrutura de um programa na linguagem .................................................................................................23
2.7 Programas sequenciais .................................................................................................................................25
2.8 Tabulação de componentes ..........................................................................................................................35
Agora é com você! ...............................................................................................................................................36
Capítulo 3 - Programação com Desvios ........................................................................37
3.1 Decisões, condições e operadores relacionais ...........................................................................................37
3.2 Desvio condicional simples .........................................................................................................................38
3.3 Desvio condicional composto .....................................................................................................................40
3.4 Desvio condicional seletivo .........................................................................................................................49
3.5 Operadores lógicos .......................................................................................................................................51
3.5.1 Operador lógico de conjunção ..........................................................................................................52
3.5.2 Operador lógico de disjunção ............................................................................................................53
3.5.3 Operador lógico de negação ...............................................................................................................55
3.6 Divisibilidade .................................................................................................................................................56
Agora é com você! ...............................................................................................................................................58
Capítulo 4 - Programação com Laços ........................................................................... 59
4.1 Laços e detalhes operacionais......................................................................................................................59
4.2 Laço condicional pré-teste ...........................................................................................................................60
4.3 Laço condicional pós-teste ..........................................................................................................................62
6 7Programação de Computadores C#
4.4 Laço incondicional .......................................................................................................................................64
4.5 Controles em tempo de execução ...............................................................................................................66
Agora é com você! ...............................................................................................................................................76
Capítulo 5 - Programação com Matrizes ....................................................................... 77
5.1 Matriz de uma dimensão .............................................................................................................................77
5.2 Matriz de duas dimensões ...........................................................................................................................81
5.3 Matriz dinâmica ............................................................................................................................................84
5.4 Ordenação e pesquisa ...................................................................................................................................86
5.5 Estrutura de registro ....................................................................................................................................90
5.6 Foreach com matrizes...................................................................................................................................96
Agora é com você! ...............................................................................................................................................99
Capítulo 6 - Programação com Sub-rotinas ................................................................. 101
6.1 Métodos e namespaces ...............................................................................................................................101
6.2 Definição de métodos .................................................................................................................................103
6.3 Uso de método sem retorno ......................................................................................................................103
6.4 Passagem de parâmetros ............................................................................................................................109
6.4.1 Passagem de parâmetro por valor ....................................................................................................110
6.4.2 Passagem de parâmetro por referência ...........................................................................................111
6.5 Uso de método com retorno ......................................................................................................................113
6.6 Métodos para cálculos matemáticos.........................................................................................................115
6.7 Métodos para cadeias de caracteres ..........................................................................................................116
Agora é com você! .............................................................................................................................................118
Capítulo 7 - Programação Orientada a Objeto .............................................................. 119
7.1 Classes ou estruturas, campos e métodos ................................................................................................119
7.2 Declaração de classe e criação de objeto ..................................................................................................121
7.3 Encapsulamento e herança ........................................................................................................................126
7.4 Polimorfismo ...............................................................................................................................................132
7.5 Aplicação gráfica .........................................................................................................................................139
Agora é com você! .............................................................................................................................................142
Bibliografia ............................................................................................................. 143
6 7
Apresentação
Este livro é um trabalho voltado para o ensino introdutório da linguagem C# para jovens e 
adolescentes dos cursos técnicos de informática da rede brasileira de ensino. O objetivo deste traba-
lho é apresentar as bases operacionais iniciais da programação orientada a objetos com a linguagem 
C#. São usados durante o estudo recursos básicos com interface gráfica moldada em formulário e 
operações em modo texto (console).
A linguagem de apresentação deste texto se caracteriza por ser voltada ao público mais jovem. 
O desenvolvimento deste livro veio da necessidade de conciliar o ensino de técnicas de programação 
aplicadas nas linguagens de programação com os parâmetros curriculares nacionais de maneira que 
se encaixasse em um período letivo de curso. Esta obra está dividida em sete capítulos que tratam os 
seguintes temas:
 » O Capítulo 1 faz uma introdução histórica do surgimento e desenvolvimento da lingua-
gem C# e da plataforma .NET. Esse capítulo comenta sobre o ambiente de trabalho Visual 
Studio e orienta sobre o processo de compilação de um programa, além de apresentar 
informações iniciais sobre programação orientada a objetos e a programação em modo 
gráfico e modo texto.
 » No Capítulo 2 o aluno tem contato com o primeiro passo do que é efetivamente a progra-
mação de computadores com C#. Estuda os conceitos de entrada,de processamento e de 
saída. É apresentado o uso de tipos de dados, variáveis, constantes, operadores aritméti-
cos, expressões aritméticas na elaboração e uso do processamento matemático. Mostra a 
estrutura básica de um programa escrito em C#.
 » A tomada de decisão, segundo passo na aprendizagem de aplicação da lógica de progra-
mação, é tema do Capítulo 3. Nesse estudo é mostrado o uso de condições e seus desvios, 
além do conhecimento e aplicação dos operadores relacionais e lógicos no uso do proces-
samento lógico. É dada atenção ao uso dos princípios de divisibilidade na tarefa de pro-
gramar computadores.
 » No Capítulo 4 é apresentado o terceiro passo a ser conhecido em uma linguagem de progra-
mação. Nessa etapa de estudo, o conhecimento de uso do processamento lógico é ampliado 
com o uso das técnicas de laços condicional pré-teste, condicional pós-teste e incondicional, 
além do uso de laços interativos.
 » Após visão da base inicial dada nos capítulos anteriores, é apresentada no Capítulo 5 a 
técnica de programação com matrizes de uma e duas dimensões. Nessa etapa é feita intro-
dução ao conceito mais simples de estruturação de dados em memória com a finalidade 
de facilitar as ações de programação pelo programador a fim de aumentar sua produti- 
vidade operacional. São indicadas orientações sobre os métodos a serem usados nas ope-
rações de ordenação e pesquisa, além de se mostrar como trabalhar com matrizes dinâmi-
cas, estruturas de registros e operações do tipo foreach.
AT8 Programação de Computadores C#
 » No Capítulo 6 é apresentada a técnica de uso de sub-rotinas em C# por meio de métodos. 
Descreve-se nessa etapa sobre métodos e namespaces. São apresentados a defi nição e o 
uso de métodos com e sem retorno de valor, além das operações com passagens de parâ-
metro por valor e por referência. O capítulo estende ainda alguns usos de método especí-
fi cos para operações matemáticas e de manipulação de cadeias de caracteres.
 » A aplicação prática e introdutória sobre programação orientada a objetos é vista no Capí-
tulo 7. Nesse sentido, são vistos detalhes sobre classes, estruturas, campos, métodos, encap-
sulamento, herança e polimorfi smo.
Espero que este trabalho seja útil não só ao aluno, mas também para o professor.
Um abraço a todos!
O autor
9AT
1
Introdução
Este capítulo tem por objetivo apresentar uma visão básica sobre os detalhes gerais encontrados 
na linguagem de programação C# e alguns recursos da plataforma .NET da empresa Microsoft . Faz-se 
um breve histórico sobre o surgimento e a evolução da plataforma .NET e da linguagem C#. O texto des-
creve o acesso ao ambiente de trabalho Visual Studio e apresenta uma visão geral básica e introdutória 
sobre a programação orientada a objeto. 
Para começar
1.1 Plataforma .NET
A plataforma .NET (lê-se dóti néti) foi lançada em 13 de fevereiro de 2002 pela empresa 
Microsoft com o objetivo de ser um ambiente gerenciado que oferece uma série de serviços para 
a execução de aplicações. Esse princípio visa facilitar o trabalho de desenvolvimento que temos de 
executar nas organizações como desenvolvedores de soft ware.
A plataforma .NET é estruturada sobre dois principais componentes: o primeiro é a CLR 
(Common Language Runtime), e o segundo, a FCL (Framework Class Library). A CLR opera como 
uma máquina virtual e é o componente responsável pelo gerenciamento e a execução do código do 
programa em uso; é um ambiente independente para a execução de linguagens. A execução da CLR 
depende da FCL, que se caracteriza por ser uma biblioteca com funcionalidades comuns a plata-
forma .NET como um todo.
1110 Programação de Computadores C#
A plataforma .NET é um ambiente que possibilita a nós programadores trabalharmos com 
várias linguagens de programação que podem ser fornecidas pela Microsoft (C#, Visual Basic .NET 
e Visual C++) ou por terceiros (Delphi, da Embarcadero) como se fossem uma única linguagem por 
meio do conceito de interoperabilidade. É possível escrever uma única aplicação a partir de diversas 
linguagens em um mesmo ambiente. No entanto, para que a interoperabilidade funcione, a plata-
forma .NET compila o código de cada linguagem usada em uma outra linguagem interna de baixo 
nível chamada CIL (Common Intermediate Language), também conhecida por IL (Intermediate 
Language) e MSIL (Microsoft Intermediate Language).
Se imaginarmos uma aplicação escrita com as linguagens C# e Visual Basic .NET (VB .NET), 
em que cada linguagem é usada para atender certa característica específica da aplicação, ocorrerá na 
plataforma .NET a compilação do código C# na linguagem intermediária IL e do código VB .NET 
na linguagem intermediária CIL, pois toda linguagem de programação da plataforma .NET é compi-
lada, por padrão, na linguagem CIL, que é a linguagem executada na plataforma .NET por meio de 
uma máquina virtual. Note que a plataforma .NET não executa programas escritos em linguagens 
como C# ou VB .NET e sim programas na linguagem CIL, que é um conjunto de instruções inde-
pendentes de plataforma que pode ser executado em qualquer CPU (Central Processing Unit).
Apesar de bem atraente a ideia de podermos criar em uma única plataforma uma aplicação a 
partir de diversas linguagens diferentes é importante considerarmos algumas regras para que esse efeito 
realmente possa ser usado. Assim, a plataforma .NET faz uso do CTS (Common Type System), que 
são regras para definir algumas ações operacionais a serem usadas nos códigos das diversas linguagens 
para que o processo de compilação possa ser efetivado, como usar os mesmos tipos de dados entre as 
várias linguagens.
Por exemplo, a definição do tipo inteiro em C# é realizada com o comando int, e em VB .NET 
é realizado com o comando Integer. Isso posto, não é possível definir uma ação de interoperabilidade 
pelo fato de os tipos inteiros definidos usarem comandos diferentes. Nesse caso a CTS define a regra 
para que a ação de interoperabilidade ocorra, ou seja, os tipos de dados a serem usados para uma 
ação de interoperabilidade não devem ser os das linguagens e sim os tipos de dados da CTS, que 
nesse caso serão para um tipo de dado inteiro o comando Int32.
Além do CTS a plataforma .NET usa para interoperabilidade a CLS (Common Language 
Specification), que são as regras que cada linguagem da plataforma .NET deve seguir para que a ação 
de interoperabilidade aconteça. São elas, entre outras:
 » Todas as linguagens da plataforma .NET usadas na ação de interoperabilidade devem ser 
orientadas a objetos;
 » Todas as linguagens devem usar tipos de dados numéricos com sinal, pois os tipos de 
dados numéricos sem sinal não são suportados;
 » Todas as linguagens podem apenas trabalhar com herança simples nas linguagens. Heran-
ças múltiplas não são aceitas;
 » Todas as linguagens devem ter os mesmos tipos de visibilidade. Tipos de visibilidade que 
não forem os esperados não são aceitos. 
As linguagens de programação da plataforma .NET podem não seguir as regras da CLS, e, 
nesse caso, não é possível fazer a ação de interoperabilidade. Veja que a interoperabilidade não é 
uma ação obrigatória.
1110 Introdução
O processo de compilação de um programa na plataforma .NET ocorre sob o aspecto de um 
modelo chamado modo gerenciado, no qual o programa escrito em certa linguagem da plataforma é 
convertido na linguagem intermediária CIL. No entanto, o processo de compilação gera um conjunto 
de metadados com outras informações do processo de compilação. O conjunto formado pelo código IL 
mais os metadados constitui o que se chama no universo .NET de código assembly. Assim sendo, 
o assembly de uma aplicação .NET é formado por um código executável ou arquivo de biblioteca 
criado a partir da linguagem IL e dos metadados. O assembly gerado é enviado à plataforma .NET para 
então ser executado, e nesse caso ocorre a segunda etapa da compilação em que o código assembly passa 
por um compilador chamado JIT (Just-In-Time), que gera o código de máquina da aplicação,basea- 
do no .NET Framework, a ser efetivamente executado pelo microprocessador do computador em uso.
É importante levarmos em consideração que o programa 
compilado na plataforma .NET só pode ser executado em um 
computador caso este tenha instalado previamente o programa 
.NET Framework, que é o ambiente que contém as bibliotecas 
necessárias à execução da CLR e do código de aplicação.
1.2 Breve histórico sobre C#
Antes de usarmos a linguagem de programação de computadores C# (lê-se cê chárpi em por-
tuguês ou ci charp em inglês), é interessante sabermos algumas curiosidades a seu respeito. Essa 
linguagem trabalha com o paradigma da programação orientada a objetos, Foi criada pela empresa 
Microsoft quando do lançamento da plataforma .NET, e antes de seu lançamento se chamava Cool.
A linguagem C# foi criada pela Microsoft do ponto zero, com influências de linguagens de 
programação, como: C++, Pascal e Java (PACIEVITCH, 2013). Pacievitch (2013) conta que o desen-
volvimento da linguagem C# auxiliou o próprio desenvolvimento da plataforma .NET.
A plataforma .NET, como já vimos, é um ambiente de 
desenvolvimento de software que possui a capacidade de inte-
grar em sua base uma série de várias linguagens de progra-
mação. Além do Visual C#, encontramos nesse ambiente as 
linguagens Basic (Visual Basic .NET) e C++ (Visual C++) for-
necidas pela empresa Microsoft, bem como poderemos ter 
linguagens fornecidas por outras empresas. No caso de uso da lin- 
guagem C++, pode-se escrever programas no modo C++ padrão ou modo C++/CLI (padrão pró-
prio da Microsoft para a plataforma .NET), além de podermos escrever programas na linguagem C 
junto ao compilador Visual C++.
A linguagem C# já passou por cinco versões, a primeira delas quando do lançamento da pla-
taforma .NET; a segunda, com o lançamento, em fevereiro de 2007, do Visual Studio 2008; depois, 
com o lançamento do Visual Studio 2010; em seguida, com o lançamento do Visual Studio 2012; e 
mais recentemente, com o lançamento do Visual Studio 2013, tema deste trabalho.
O desenvolvimento da linguagem C# foi liderado pelo engenheiro de desenvolvimento Anders 
Hejlsberg, que no passado era funcionário da empresa Borland, onde liderou o desenvolvimento do 
Turbo Pascal e do Delphi, e também pelo engenheiro Scott Wiltamuth.
O termo paradigma, muito usado na área 
de programação de computadores, se 
refere na verdade ao uso de um modelo, 
uma forma, a ser seguido.
 Atualmente, a atividade de programa-
ção de computadores está em diversos 
equipamentos eletrônicos de todos os 
tamanhos.
1312 Programação de Computadores C#
Podemos usar a linguagem C# de duas maneiras, para produzir programas em modo console 
(interface texto) e em modo gráfico (interface gráfica). Quando em modo console, só é possível usar-
mos o paradigma de programação orientada a objetos, mas quando usamos o modo gráfico é possível 
fazermos uso também do paradigma de programação orientada a eventos. É importante considerar-
mos que objetos e eventos são coisas diferentes: o objeto é um elemento para guardarmos informações 
de um dado e do comportamento desse dado; evento está associado a uma ação executada na interface 
gráfica. É muito comum as pessoas confundirem esses conceitos.
Assim, um evento só existe quando há um formulário com componentes que necessitam ser con-
trolados de alguma maneira para que um programa seja executado. Por exemplo, você cria um formu-
lário com componentes texto para serem preenchidos e cria um botão que quando acionado envia o 
conteúdo do formulário para um arquivo; o controle da ação do botão é um evento, e, quando dispa-
rado, pode acionar uma rotina de programa orientado a objeto para realizar a ação. Veja que evento e 
objetos são diferentes.
Em dezembro de 2001, a Microsoft submeteu a linguagem C# à ECMA (European Computer 
Manufacturers Association) para a padronização formal da linguagem. De acordo com esse órgão de 
padronizações, o documento de padronização da linguagem é referido como ECMA-334. A lingua-
gem C# em 2003 passou a ser um padrão ISO (ISO/IEC 23270). Essas padronizações visam manter a 
homogeneidade da linguagem quando outras empresas ou grupos de usuários começam a desenvolver 
outras soluções para a linguagem, como o BDS 2008 da CodeGear, Portable .NET da Free Software 
Foundation e Mono da Novell.
1.3 O ambiente de programação
Para estudarmos a linguagem C# é necessário termos instalado no computador que vamos 
usar o programa Visual Studio. Não faremos menção à aquisição e instalação do ambiente, pois esta-
mos considerando o uso a partir de um computador que já o tenha.
Para termos acesso ao programa Visual C#, é necessário executarmos no Windows 7 a seguinte 
ação de chamada:
Menu Iniciar
Todos os Programas
Microsoft Visual Studio 2013 Express
VS Express for Desktop
Para termos acesso ao programa Visual C#, é necessário executarmos no Windows 8 a seguinte 
ação de chamada:
Tela Iniciar
Ícone: VS Express for Desktop
Na sequência, será apresentada a tela do ambiente do programa Microsoft Visual Studio 
Express 2013 for Windows Desktop, Figura 1.1.
1312 Introdução
Para fazer uso do modo de operação Visual C#, selecione no menu FILE a opção New Project..., 
que apresentará a caixa de diálogo New Project, Figura 1.2. Selecione no menu lateral esquerdo, em 
Templates, a opção Visual C#.
A caixa de diálogo New Project apresenta a forma de projetos que podem ser selecionados. 
Nesta obra, serão usados dois modos de trabalho: Windows Forms Applications (para criamos apli-
cações em modo gráfico) e Console Applications (para criarmos aplicações em modo console - texto).
Figura 1.1 - Ambiente de programação VS.
Figura 1.2 - Caixa de diálogo “New Project”.
1514 Programação de Computadores C#
É importante esclarecer que não adianta sabermos desenhar belas telas gráficas no ambiente 
Visual C# e ter dúvidas na forma de operação de suas instruções em nível lógico. O conhecimento de 
lógica de programação e algoritmos é muito importante para essa etapa de nossa aprendizagem.
Nosso estudo focará o uso do desenvolvimento de aplicações a partir do modo gráfico. No 
entanto, as Figuras 1.3 e 1.4 mostram, respectivamente, o formato de tela para os modos de desen-
volvimento console e gráfico.
A Figura 1.3, na parte superior, mostra a barra de título nomeada pelo rótulo ConsoleApplication1 
- Microsoft Visual Studio Express 2013 for Windows Desktop. A identificação ConsoleApplication1 é o 
nome do projeto em uso. Essa tela é apresentada quando se faz a seleção da opção Console Applications. 
Todo programa escrito nessa opção usa a tela do modo texto do sistema operacional. 
Figura 1.3 - Tela de projeto em modo console.
A Figura 1.4 mostra, na parte superior, a barra de título nomeada pelo rótulo WindowsForms- 
Application1 - Microsoft Visual Studio Express 2013 for Windows Desktop. A identificação Windows-
FormsApplication1 é o nome do projeto em uso. Essa tela é apresentada quando se faz a seleção da 
opção Windows Forms Applications. Todo programa escrito nessa opção deve usar formulários para 
ser executado.
Independentemente da opção selecionada, abaixo da barra de título há a barra de menu, que, 
dependendo do modo em uso, pode ser diferente. Por exemplo, se estiver aberta a página inicial da 
tela, os comandos de menu serão: FILE, EDIT, VIEW, PROJECT, BUILD, DEBUG, TEAM, TOOLS, 
TEST, WINDOW e HELP; no entanto, se for a página de acesso à criação de um projeto, os coman-
dos de menu serão: FILE, EDIT, VIEW, PROJECT, BUILD, DEBUG, TEAM, FORMAT, TOOLS, 
TEST, WINDOW e HELP.
1514 Introdução
Figura 1.4 - Tela de projeto em modo gráfico.
Abaixo da barra de menu, encontra-se a barra de ferramentas do programa, com os botões que 
simplificam algumas das ações do menu do programa.
Abaixo da barra de ferramentas, do lado esquerdo da tela, encontra-se a janela Program.cs (para 
o modo console) ou Form1.cs (para o modo gráfico). Note que, na margem esquerda dessa janela, 
estão as abas de opção Toolboxe DataSources se estiver em uso o modo gráfico. Se estiver em uso o 
modo texto, é apresentada a aba Toolbox. Do lado direito da janela de projeto, há a janela Solution 
Explorer.
No extremo inferior, identificado pelo rótulo Ready, encontra-se a barra de estado do pro-
grama em que podem ser apresentadas informações das ações.
Para sair, selecione a partir do menu FILE a opção Exit.
1.4 Programação orientada a objetos
A programação de computadores com orientação a objetos como a conhecemos atualmente 
não é recente. Sua divulgação ao público de forma mais popular data do início da década de 1990. 
O nome Programação Orientada a Objetos foi definido em 1984 quando a empresa Xerox lançou a 
linguagem SmallTalk.
O que muitos de nós não conhecemos é que o conceito de Programação Orientada a Objetos, 
ou POO, surgiu a partir da década de 1960. Nessa ocasião, já havia uma grande preocupação com a 
qualidade dos softwares desenvolvidos, com o reaproveitamento de código escrito e com o tempo de 
desenvolvimento dos sistemas, que começava a ser longo.
1716 Programação de Computadores C#
O cenário para a área de soft ware não era nada animador, pois a indústria de hardware estava 
muitos anos à frente. O modo de criação dos programas era muito primário (BUENO, 2002), pois 
um programa tinha de ser escrito para um computador em específi co. Não existia a concepção de 
escrever um programa que pudesse ser executado em qualquer computador ou qualquer plataforma 
computacional. Essa concepção só apareceu muito tempo depois.
A linguagem Java, orientada a objetos, criada em 1991 na Sun Microsystems, é a principal concorrente direta da lingua-
gem C#.
Amplie seus conhecimentosAmplie seus conhecimentos
Entre 1954 e 1968, surgiram as primeiras linguagens de programação de computadores de 
alto nível (maior proximidade com a escrita humana, em inglês), e a primeira a ser lançada foi a 
FORTRAN (FORmula TRANslator, criada por John Backus para a IBM em 1954). Depois vieram o 
COBOL (COmmon Business Oriented Language, criado pela almirante Gracy Murray Hopper para 
o Departamento de Defesa Norte-Americano em 1959), ALGOL (ALGOrithmic Language, criada 
por um comitê internacional formado pela Association for Computing Machinery e German Applied 
Mathematics and Mechanics em 1958) e BASIC (Beginner’s All Purpose Symbolic Instruction Code, 
criada por J. Kemeny and T. Kurtz em 1964), para citar as mais conhecidas, já que existem mais de 2,5 
mil linguagens de programação catalogadas. Essas linguagens passaram a defi nir a segunda geração.
Além de serem mais próximas da escrita humana, essas linguagens de programação possibi-
litaram maior portabilidade, pois já era, mesmo que de forma precária, possível escrever um pro-
grama para um computador e utilizá-lo (com algumas modifi cações) em outro computador.
As linguagens de segunda geração, na sua maioria, são lineares, e identifi cam seus comandos 
com linhas numeradas. Essa característica difi culta a adoção de técnicas estruturadas de codifi cação 
de programa. Não que essas linguagens não permitam o uso da técnica, apenas difi cultam um pouco, 
o que leva programadores inexperientes a cometerem verdadeiros absurdos na codifi cação de seus 
programas. Em razão desse e de outros detalhes técnicos, começa a se discutir uma maneira de ten-
tar reaproveitar um código escrito sem a necessidade de alterá-lo.
Essa ideia inicial norteia o conceito de programação orientada a objetos, que surge a par-
tir de 1960, com dois pesquisadores: Ole-Johan Dahl e Kristen Nygaard , que apresentaram, em 
1965, a primeira linguagem de programação com elementos que seriam a base para a programa-
ção orientada a objetos, como a conhecemos, chamada SIMULA I, para computador UNIVAC do 
Norwegian Computing Center. Em 1967, apresentaram a linguagem SIMULA 67 . 
Toda linguagem orientada a objeto é, por defi nição, uma linguagem de programação com 
forte suporte à programação estruturada de dados. Surgem então as primeiras linguagens de pro-
gramação pertencentes à terceira geração, com uma estruturação maior que as linguagens de 
segunda geração, mas não davam inicialmente o suporte à programação orientada a objetos, que 
estava ainda engatinhando.
Entre 1968 e 1972, surgem as linguagens PASCAL e C (que não são orientadas a objetos, mas 
são estruturadas, logo são linguagens de terceira geração). Depois, com o tempo, vieram outras lin-
guagens de programação, as quais já embutiam de alguma forma os conceitos de orientação a objeto , 
1716 Introdução
tais como SMALLTALK, EIFFEL, ADA, CLOS, SELF, BETA, OBJECT PASCAL (linguagem Pascal 
orientada a objetos) e C++ (linguagem C orientada a objetos), entre outros exemplares, muitos 
dos quais ainda desconhecidos por boa parte do público profissional da área de TI (Tecnologia da 
Informação), que não cabe listar neste estudo, e que surgiram a partir de 1980. Depois vieram as 
linguagens Java e C#.
No entanto, não basta apenas existirem o conceito, as ferramentas e a vontade para a imple-
mentação de sistemas baseados em orientação a objetos; é necessário que nós desenvolvedores tam-
bém pensemos nossa lógica de acordo com a programação orientada a objeto. 
Os conceitos de orientação a objeto que estudaremos na linguagem C# serão apresentados na 
medida em que forem necessários ao uso. Inicialmente vamos abordar: classe, objeto, campo (atri-
buto) e método.
Para podermos criar programas orientados a objetos, precisamos inicialmente conhecer e desen-
volver estruturas de dados para esse tipo de ação chamadas classes. Uma classe é uma forma que temos 
para definir um modelo para um objeto; é uma maneira de criar um tipo de dado tunado que será 
associado a um objeto. A estrutura de uma classe é formada por até dois grupos de elementos: campos 
(componentes estruturais da classe) e métodos (funcionalidade da classe).
Os campos de uma classe são elementos que representam as características dessa classe. Esses 
campos são nomeados por meio de substantivos. Há profissionais que chamam esse elemento de 
atributo. Isso não é errado, mas na linguagem C# há outro elemento operacional que recebe o nome 
de atributo. Por essa razão vamos usar o termo campo para diferenciar do termo atributo quando o 
uso deste for necessário. 
Os métodos de uma classe determinam as operações a serem realizadas pelo objeto instan-
ciado. Os métodos são nomeados por meio de verbos.
Um objeto é definido a partir de uma classe. Dizemos então que o objeto é uma instância da 
classe definida, ou seja, o objeto é modelado a partir da estrutura definida na classe a ele associa- 
do (instanciado).
1.5 Programação em modo gráfico ou em 
modo console
O uso do modo gráfico ou do modo console (interface texto, como muitos chamam) em pro-
gramação é um tema a ser considerado por nós programadores. É incrível como há preconceito téc-
nico em relação ao uso do mecanismo de programação para a produção de programas em modo 
texto, pois é muito comum ouvirmos coisas como: a programação em modo console é perda de 
tempo, quem iria querer usar isso?, programador que é programador desenvolve em modo gráfico. 
Essas e outras questões aparecem nas discussões e são sempre infundadas.
Será que uma empresa de desenvolvimento de software como é a Microsoft, desenvolvedora 
do ambiente Visual Studio, colocaria esse modo de programação para perder tempo, tirar uma com 
a nossa cara de programador? É claro que não. O modo de programação em console existe para o 
desenvolvimento de programas que necessitam de maior velocidade de execução, de programas 
AT18 Programação de Computadores C#
voltados para necessidades específi cas em que a parte gráfi ca não é um requisito operacional neces-
sário. A parte gráfi ca é apreciada para o desenvolvimento de aplicações para o público geral.
Esta nossa discussão tem por objetivo deixar claro que temos de estar abertos para o desen-
volvimento de programas para esses dois modos de operação. Muitas pessoas se preocupam com 
a cereja do boloe esquecem o bolo. Concentrar nossos esforços somente na parte gráfi ca poderá 
fazer com que acabemos nos preocupando com a cereja, quando o bolo é a parte mais importante, 
a cereja é só o acabamento. Não que a cereja não mereça nossa atenção, mas não é só ela que 
necessita de atenção.
A linguagem C#, quando usada em modo gráfi co, nos dá dois pontos de atenção, sendo a 
interface gráfi ca a ser desenvolvida onde deveremos nos preocupar com os eventos a serem pro-
cessados quando, por exemplo, um botão é acionado e a parte operacional do código associada ao 
evento do botão quando acionado. Veja que o modo gráfi co exige de nós atenção em dois pontos 
essenciais do programa: a parte gráfi ca e o código associado à parte gráfi ca (interface do usuário), 
além, é claro, do código do programa em si. No modo console a interface do usuário é simples, e o 
ponto de maior atenção é o código em si. Assim, vemos que há vantagens e desvantagens em ambos 
os modos de programação.
No estudo que vamos fazer neste material, usaremos os dois modos de programação. O estudo 
é iniciado com aplicações em modo gráfi co, no qual veremos os comandos mais comuns de uso da 
linguagem. No desenvolvimento da evolução do que estaremos estudando, veremos mais à frente 
aplicações simples em modo console, pois nesse momento estaremos nos concentrando no uso de 
instruções específi cas e nossa atenção estará voltada ao entendimento dessas instruções.
Neste capítulo foi descrita uma visão básica sobre a linguagem de programação C# e sobre a pla-
taforma .NET. Foram mostrados seu ambiente de uso e os conceitos gerais sobre programação orientada 
a objetos.
Vamos recapitular?
Agora é com você!
Faça uma pesquisa e localize outras informações, diferentes das apresentadas neste 
capítulo, sobre linguagem C# e plataforma .NET. Produza uma dissertação com uma média 
de 35 linhas impressas com os apontamentos coletados na pesquisa que deverá ser entregue 
ao seu professor. Não copie os textos pesquisados, escreva os apontamentos com suas pró-
prias palavras.
19AT
2
Programação 
Sequencial
Este capítulo tem por objetivo apresentar detalhes relacionados a tipos de dados usados na lin-
guagem C#. Descreve o conceito e a aplicação de variáveis e constantes. Mostra os operadores aritmé-
ticos e as expressões aritméticas advindas do uso de tais operadores. Descreve a estrutura básica de um 
programa escrito na linguagem. Demonstra o uso de programas sequenciais permeando as ações de 
entrada, processamento matemático e saída com cadeias de caracteres, valores inteiros e valores reais.
Para começar
2.1 Tipos de dados
Os dados que usamos em um computador representam os elementos do mundo exterior, que 
são as informações manipuladas por nós seres humanos. Os dados utilizados no computador devem 
primeiramente ser abstraídos e então processados. Podem ser categorizados em três tipos primitivos 
ou básicos: numéricos (representados por valores numéricos inteiros ou reais), caracteres (valores 
alfabéticos ou alfanuméricos) e lógicos (valores falsos e verdadeiros).
A linguagem C# nos oferece um conjunto de tipos de dados predefi nidos, classifi cados em: numé-
rico inteiro, numérico de ponto fl utuante,1 caractere e lógico. Os tipos de dados são usados a fi m de alocar 
espaço de memória para armazenamento e manipulação de valores de trabalho de um programa.
1 Ponto fl utuante (notação científi ca) é a maneira usada em computadores para representar digitalmente números reais (formado 
por um expoente - parte inteira, um ponto de separação e uma mantissa - parte fracionária). Dessa forma é possível cobrir uma 
extensa faixa numérica em um pequeno espaço de memória.
2120 Programação de Computadores C#
A Tabela 2.1 nos mostra os tipos de dados, a faixa de abrangência de cada tipo e o tamanho 
que cada tipo ocupa na memória do computador.
Tabela 2.1 - Tipos de Dados Inteiros
Tipo de dado inteiro Faixa de abrangência Tamanho
short 
de -32.768
até 32.767
16 bits
ushort 
de 0
até 65.535
16 bits
int 
de -2.147.483.648
até 2.147.483.647
32 bits
uint 
de 0
até 4.294.967.295
32 bits
long 
de -9.223.372036.854.775.808
até 9.223.372036.854.775.807
64 bits
ulong 
de 0
até 18.446.744.073.709.551.615
64 bits
float 
de -3.4028235e38
até 3.4028235e38
32 bits
double 
de -1.79769313486231e308
até 1.79769313486231e308
64 bits
decimal 
de 0
até +/-79.228.162.514.264.337.593.543.950.335
128 bits
byte 
de 0
até 255
8 bits
sbyte 
de -128
até 127
8 bits
char 
de 0 caractere
até 65.535 caracteres
16 bits
string 
de 0 caractere
até 2.000.000.000 caracteres aproximados
16 bits
bool 
falso (False ou 0)
verdadeiro (True ou qualquer valor numérico)
16 bits
object 
Referência feita a variáveis instanciadas a partir de um 
objeto
32 bits
2120 Programação Sequencial
Os valores do tipo float são usados para definir números de ponto flutuante (números fracioná-
rios) com sete dígitos decimais de precisão absoluta - precisão simples, enquanto o double é utilizado 
para representar números de ponto flutuante com 15 ou 16 dígitos decimais de precisão absoluta - pre-
cisão dupla.
O tipo string que representa uma cadeia (considere como sendo um conjunto de char) de 
caracteres opera com valores inteiros baseados nos códigos estabelecidos na tabela ASCII.2
Dados do tipo char (caracteres) são valores inteiros para a representação de letras, números e 
símbolos especiais da tabela ASCII delimitados por aspas inglesas [" e "], erroneamente chamadas 
de aspas duplas.
O Brasil possui uma linguagem de programação reconhecida internacionalmente, chamada Lua, desenvolvida na PUC do 
Rio de Janeiro e usada em todo o mundo por grandes empresas como a Lucas Arts e Microsoft. Para saber mais, consulte 
o site www.lua.org
Fique de olho!
2.2 Variáveis
Qualquer informação a ser processada em um computador por um programa necessita ser 
previamente armazenada na memória. Conseguimos executar essa ação quando usamos variáveis. 
Uma variável é uma região de memória, previamente identificada por um rótulo (nome), que tem 
por finalidade armazenar os dados de um programa temporariamente. Cada variável armazena 
apenas um valor por vez, sendo esse valor um elemento qualificado a partir de um dos tipos de 
dados da linguagem.
O nome de uma variável é usado para sua identificação e posterior manipulação dentro do 
programa. Para usar variáveis, precisamos considerar algumas regras quanto aos nomes que pode-
mos definir. São elas:
 » Nome de variável pode ser atribuído com um ou mais caracteres.
 » O primeiro caractere do nome de uma variável não pode ser em nenhuma hipótese um 
número; sempre deve ser uma letra.
 » O nome de uma variável não pode ter espaços em branco.
 » Não pode ser nome de uma variável uma palavra reservada a uma instrução ou um iden-
tificador de uma linguagem de programação, bem como o nome de seus controles.
 » Não podem ser utilizados outros caracteres que não letras e números, com exceção do 
caractere underscore "_", que pode ser utilizado para simular a separação de duas pala-
vras, como Nome_Aluno, que também podem estar escritas como NomeAluno. 
Dentro de um programa uma variável pode exercer dois papéis, um de ação, quando ela é 
modificada ao longo de um programa para apresentar um determinado resultado, e o outro de con-
2 American Standard Code Information Interchange.
2322 Programação de Computadores C#
trole, quando ela é vigiada e controlada durante a execução de um programa (esse tipo de variável 
será estudado nos capítulos que abordam a tomada de decisões e o uso de laços).
Todo dado a ser armazenado na memória de um computador por meio de uma variável deve 
ser armazenado previamente, ou seja, primeiramente é necessário saber o seu tipo para depois fazer 
o seu armazenamento. Uma vez armazenado, o dado pode ser utilizado e manipulado a qualquer 
momento durante a execução do programa.
2.3 Constantes
Tudo que é fixo, estável, inalterável, imutável, contínuo, incessante, invariável, devalor fixo é con-
siderado constante. Assim, do ponto de vista computacional, uma constante é uma grandeza numérica 
fixa, que usamos em uma expressão aritmética ou matemática, pela qual definimos um valor que será 
inalterado na expressão, independentemente das variáveis envolvidas na operação a ser realizada.
Como exemplo prático pode-se considerar a constante matemática pi, que equivale ao valor apro- 
ximado 3.14159265, ou então a expressão matemática SAIDA = ENTRADA + 1.23, em que o valor 
1.23 é a constante da expressão e SAIDA e ENTRADA são, respectivamente, as variáveis da expressão.
Do ponto de vista computacional, além de ser um valor fixo, usado em uma expressão aritmé-
tica ou matemática, uma constante pode ser usada como rótulo de identificação. No caso das lingua-
gens C e C++ a maneira mais comum que temos para definir uma constante é fazendo uso da diretiva 
define por meio da sintaxe: #define <rótulo de identificação> <valor constante>. Assim, a expressão 
matemática SAIDA = ENTRADA + PI é, do ponto de vista computacional, formada pelas variáveis 
SAIDA e ENTRADA e pela constante PI, que podemos definir com a instrução const PI 3.14159265.
Um ponto importante que devemos considerar é que uma variável ocupa espaço na memória do 
computador, pois, quando é definida, segundo o tipo associado, o compilador aloca na memória espa- 
ço para armazenar o valor associado. Já uma constante é definida de maneira diferente. Ela não ocupa 
espaço na memória por se tratar apenas de um rótulo associado a um valor que será usado pelo pro-
grama, e esse valor não é armazenado em memória, ficando apenas vinculado ao código do programa.
2.4 Operadores aritméticos
Tanto variáveis como constantes podem ser usadas na elaboração de cálculos matemáticos 
com operadores aritméticos. Os operadores aritméticos podem ser unários ou binários. São binários 
quando atuam em operações de exponenciação, multiplicação, divisão, adição e subtração, em que se 
utilizam dois componentes. São unários quando atuam na inversão de um valor, atribuindo a ele o 
sinal positivo ou negativo, ou seja, atuam diretamente em apenas um componente. A Tabela 2.2 nos 
mostra os operadores aritméticos utilizados nas linguagens C e C++: 
Tabela 2.2 - Operadores Aritméticos
Operador Operação Tipo Resultado
+ Manutenção de sinal Unário -
- Inversão de sinal Unário -
2322 Programação Sequencial
Operador Operação Tipo Resultado
% Resto de divisão (módulo) Binário Inteiro
/ Divisão Binário Inteiro ou Real
* Multiplicação Binário Inteiro ou Real
+ Adição Binário Inteiro ou Real
- Subtração Binário Inteiro ou Real
Math.Pow(base, expoente) Exponenciação Binário Inteiro ou Real
Math.Sqrt(base) Raiz quadrada Unário Inteiro ou Real
Na tabela anterior, as funções Math.Pow() e Math.Sqrt() não são operadores aritméticos, mas 
elas facilitam operações de exponenciação e radiciação, que são matemáticas. Por essa razão, citamos 
essas funções com os demais operadores aritméticos.
2.5 Expressões aritméticas
É comum usarmos em um programa expressões aritméticas quando necessitamos efetuar cálcu- 
los matemáticos. Nessas expressões definimos o relacionamento existente entre variáveis e constan-
tes numéricas com a utilização dos operadores aritméticos.
Considere a fórmula AREA = p . RAIO2 para o cálculo da área de uma circunferência, em que 
estão presentes as variáveis AREA e RAIO, a constante p (pi = 3.14159 ...), os operadores aritméticos 
de multiplicação e, também, a operação de potência, elevando o valor da variável RAIO ao quadrado.
As expressões aritméticas que usamos em um computador têm formato diferente do conhe-
cido em matemática. Por exemplo, a expressão X = {43 . [55 : (30 + 2) ] } será escrita em C ou C++ 
como X = (43 * (55 / (30 + 2) ) ). Perceba que as chaves e os colchetes são abolidos, ficando em seu 
lugar apenas os parênteses. A fórmula para cálculo da área de uma circunferência seria escrita da 
seguinte maneira: AREA = 3.14159 * RAIO * RAIO.
E a fórmula a ser utilizada para calcular a área de um triângulo, em que é necessário multi-
plicar a base pela altura e, em seguida, dividir pela constante 2, como ficaria? Observe a fórmula 
padrão seguinte:
A b h= ⋅
2
Ela deveria ser escrita como A = (B * H) / 2.
2.6 Estrutura de um programa na linguagem
Antes de escrevermos um programa na linguagem C# é necessário que conheçamos sua 
estrutura mínima de operação e definição de código de programa, pois essa linguagem é do tipo 
2524 Programação de Computadores C#
case-sensitive. Isso significa que a linguagem diferencia caracteres maiúsculos de caracteres minús-
culos, sendo necessário muita atenção e cuidado na codificação dos programas.
A linguagem de programação se comunica com o computador segundo um formato sintático 
básico e próprio. As instruções de código podem ser formadas por um ou mais comandos, escritos 
em uma ou mais linhas. O final de uma instrução é indicado com o uso de um ponto e vírgula.
Veja, em seguida, o menor programa que podemos ter na linguagem C# para modo gráfico 
após solicitarmos a abertura de um projeto de trabalho. O código de programa seguinte é gerado 
automaticamente pelo ambiente Visual Studio.
 1: using System;
 2: using System.Collections.Generic;
 3: using System.ComponentModel;
 4: using System.Data;
 5: using System.Drawing;
 6: using System.Linq;
 7: using System.Text;
 8: using System.Windows.Forms;
 9:
10: namespace WindowsFormsApplication1
11: {
12: public partial class Form1 : Form
13: {
14: public Form1()
15: {
16: InitializeComponent();
17: }
18: }
19: }
Perceba que, antes da instrução da linha 10 com o comando namespace que é a área onde o 
código de um programa C# é definido, são apresentadas algumas linhas com o uso da cláusula using 
seguida dos nomes de identificação das bibliotecas de classes e métodos externos que serão usados 
pelo programa. Veja que essas linhas foram automaticamente colocadas no código e representam as 
classes definidas em outros namespaces que não os que estão em uso. Um namespace em C# é uma 
estrutura de acesso a recursos internos e disponíveis à linguagem C#.
Ao observamos as linhas de 1 a 8, devemos considerar que cada comando using faz a chamada 
de um namespace específico e que cada namespace por si só é um conjunto de grupos lógicos de recur-
sos relacionados. Note que os namespaces são organizados hierarquicamente e que todos descen-
dem do namespace System apontada na linha 1. Na linha 2 é feita a chamada do namespace System. 
Collections responsável por disponibilizar diversos recursos para uso de ações relacionados ao trata-
mento de estruturas de dados e operações em listas baseadas em coleções de recursos. O namespace 
System.ComponentModel indica na linha 3 os recursos para criação de componentes. A linha 4 usa 
o namespace System.Data responsável ao acesso de recursos relacionados ao uso de bancos de dados. 
2524 Programação Sequencial
O namespace System.Drawing da linha 5 possui os recursos para gerenciamento do comportamento 
gráfico da aplicação. Na linha 6 temos o namespace System.Linq que fornece recursos relacionados a 
consultas com LINQ (Language-Integrated Query). A linha 7 faz uso do namespace System.Text, que 
se relaciona à representação da codificação de caracteres em formato ASCII e Unicode. Por último o 
namespace System.Windows.Forms é usado para a criação de aplicações em modo gráfico.
Devemos considerar que o código gerado automaticamente coloca em uso alguns namespaces 
e que essencialmente pode ocorrer de não usarmos certos recursos do que é disponibilizado e que 
por vezes precisaremos mencionar namespaces que não tenham sido chamados.
O comando namespace da linha 10 (nome do espaço de trabalho do programa) estabelece o 
nome da área de operação do programa na memória principal. O comando namespace, seguido de 
um dos identificadores, representa uma instrução cuja área de abrangência de ação se concentra em um 
blocooperacional, identificado pelo uso dos símbolos de chaves. Nesse caso, nas linhas 11 e 19, onde 
o programa será definido. Parte do código dessa região será gerada automaticamente quando com-
ponentes gráficos forem sendo definidos no formulário principal de operação.
A instrução public partial class Form1 : Form marca o programa principal onde estará o for-
mulário que será apresentado quando da execução do programa. A área de abrangência dessa ins-
trução se concentra no trecho descrito entre as linhas 13 e 18. O uso da cláusula partial faz com que 
o código da estrutura de dados, nesse caso, uma class, seja dividido em dois ou mais arquivos-fonte. 
As estruturas passíveis de divisão são class, struct e interface. A divisão parcial de estruturas possibi-
lita uma organização de código em que é possível dividir uma classe grande em vários arquivos.
O qualificador, ou seja, a cláusula public é utilizada com um método, tendo por finalidade 
indicar que o método à sua frente é externamente reconhecido por outras classes. Com a cláusula 
public fica fácil estabelecer e usar colaboração, agregação, acoplamento e generalização entre classes.
2.7 Programas sequenciais
Um programa sequencial é um programa que escrevemos a partir de três ações básicas e 
necessárias que um programa deve executar em um computador, que são: a entrada dos dados, o 
processamento dos dados e a saída dos dados processados. Apesar de ser essa a forma mais simples 
de escrevermos um programa, ela é a mais importante de todo nosso aprendizado, pois é por meio 
dela que escreveremos as interfaces de entrada e saída com os usuários dos nossos programas.
A etapa de processamento é executada a partir de duas possibilidades: o processamento 
pode ser matemático ou lógico. É matemático quando executa qualquer operação de cálculo mate-
mático, e será lógico quando executa qualquer operação de controle que não use ações matemáti-
cas de forma isolada.
Para podermos criar qualquer programa para a linguagem C# no ambiente Visual Studio é 
necessário criar um projeto para essa finalidade. Cada programa possuirá seu projeto. Assim, a cria-
ção de projetos é conseguida com a seguinte sequência de chamada.
2726 Programação de Computadores C#
Para acesso ao programa Visual C#, execute no Windows 7 a seguinte ação de chamada:
Menu Iniciar
Todos os Programas
Microsoft Visual Studio 2013 Express
VS Express for Desktop
Para acesso ao programa Visual C#, execute no Windows 8 a seguinte ação de chamada:
Tela Iniciar
Ícone: VS Express for Desktop
Em seguida, selecione, na barra de menu, os comandos:
FILE
New Project...
Na caixa de diálogo New Project apresentada, selecione do lado esquerdo a opção Templates/
Visual C#/Windows. Selecione, em seguida, a opção Windows Forms Application. Informe, no campo 
Name, o nome do projeto, nesse caso, Cap02_Ex01, Figura 2.1, e em seguida acione com o ponteiro do 
mouse o botão OK. Em seguida, é apresentada a área de trabalho, Figura 2.2.
Figura 2.1 - Caixa de diálogo New Project.
2726 Programação Sequencial
Figura 2.2 - Apresentação da área de trabalho.
Selecione o menu VIEW, escolha a opção Toolbox e será apresentada, ao lado esquerdo da tela, 
a janela Toolbox, Figura 2.3.
Figura 2.3 - Apresentação da barra de ferramentas, lado esquerdo.
2928 Programação de Computadores C#
Na sequência, acione o botão Auto Hide (semelhante a uma tachinha) da janela Toolbox para 
que a janela da barra de ferramentas seja fi xada ao lado da área de trabalho, como mostra a Figura 2.4. 
Em seguida, selecione na árvore de opções de Toolbar a opção All Windows Forms.
Figura 2.4 - Janela da barra de ferramentas fi xada na área de trabalho.
Os próximos exemplos nos mostrarão, por meio de exercícios resolvidos, diversas situações em 
que são usados os procedimentos de entrada, processamento e saída com números inteiros, núme-
ros reais e cadeias de caracteres. A cada exercício apresentamos detalhes operacionais de uso do 
ambiente e da linguagem que deverão ser conhecidos para a continuidade deste estudo. Acompanhe 
cada exemplo e suas respectivas descrições.
Exercício resolvido
Elabore um programa de computador que por meio de uma tela solicite o nome de uma pessoa 
e faça a apresentação do nome após o acionamento de um botão de ação (componente Button). 
A entrada do nome deve ser efetuada em um componente do tipo Textbox, e a saída deve ser rea-
lizada no componente Label.
Procedimentos operacionais
Localize, na lista da ferramenta Toolbox , o controle (às vezes referenciado como componen-
te) TextBox que será usado para efetuar a entrada do nome. Para selecioná-lo, basta um cli-
que sobre o controle desejado e levá-lo para dentro do formulário Form1 , o qual será fi xado 
por meio de um clique dentro da área pretendida. Insira o controle, arrastando-o para o canto 
superior esquerdo, Figura 2.5, e coloque também um controle Button abaixo do controle ante-
rior. A Figura 2.6 mostra como deve fi car a sua área de trabalho (desktop).
2928 Programação Sequencial
Figura 2.5 - Controle TextBox, 
inserido no formulário Form1.
Figura 2.6 - Controle Button, 
inserido no formulário Form1.
Agora que escolhemos dois controles como mecanismo de entrada e de ação para apresentar o 
nome informado, falta definir um terceiro controle para apresentar o nome informado. Nesse 
caso, selecione o controle Label e insira-o no formulário. A Figura 2.7 exibe o controle Label 
com o nome label1.
A partir desse momento o formulário está monta-
do. Se for solicitada a execução do programa, nada 
irá ocorrer, pois é necessário ainda indicar o código 
de programa de seu processamento.
Um programa escrito na linguagem C# é a junção 
do formulário, no caso Form1, com um código de 
programa existente que será de fato o projeto do 
programa.
Assim, a partir do formulário ativo, dando um duplo 
clique no controle button1 surge a janela de código 
do programa. Na janela apresentada, escreva apenas 
a linha de código indicada a seguir em negrito:
Figura 2.7 - Controle Label1, 
inserido no formulário Form1.
Codificação em Linguagem C#
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace Cap02_Ex01
3130 Programação de Computadores C#
{
 public partial class Form1 : Form
 {
 public Form1()
 {
 InitializeComponent();
 }
 private void button1_Click(object sender, EventArgs e)
 {
 label1.Text = textBox1.Text;
 }
 }
}
Para gravar o projeto, execute o comando FILE/Save All, e para verificar o funcionamento do 
programa, execute o comando do menu DEBUG/Start Debugging e aparece a tela do progra-
ma, ou acione a tecla de função <F5>.
Perceba que o conteúdo do controle Label1 vai ser atribuído com o conteúdo informado e 
armazenado no controle TextBox1.
Após o comando private void, é indicado o uso do método button1_Click() criado automatica-
mente quando da seleção com um duplo clique. Esse método, para operar o evento indicado, necessita 
de dois argumentos, mesmo que estes não sejam usados, como é o caso deste exemplo. Note a definição 
de duas variáveis, uma chamada sender do tipo object e a outra chamada e do tipo EventArgs. A variá- 
vel sender está sendo definida como um objeto derivado a partir de uma classe genérica .NET usado 
para, se necessário, tratar um método instanciado a partir de object de forma estática. Já a variável e é 
usada para tratar certo evento de dados.
Agora que o programa está em execução, entre um nome qualquer no campo em que está escrito 
text1. Após digitar o nome desejado, dê um clique no botão button1, e o nome será apresentado no 
componente label1. A Figura 2.8 mostra como deve ficar a tela após a entrada e apresentação do nome.
Figura 2.8 - Tela do programa após seu funcionamento.
Para encerrar a execução do programa, basta um cliqueno botão com um X no canto superior 
direito da aplicação. Daqui por diante, o processo de montagem de um programa fica mais fácil. 
Basta seguirmos as instruções indicadas. Para gravar o projeto, execute o comando de menu FILE e 
selecione a opção Save All.
3130 Programação Sequencial
Exercício resolvido
Será desenvolvido um programa que faça a leitura de dois valores numéricos do tipo intei-
ro. Em seguida, processe a adição dos valores fornecidos e apresente o resultado. Execute o 
comando FILE/New Project, forneça o nome Cap02_Ex02 para o projeto e acione o botão OK. 
Lembre-se de manter selecionada do lado esquerdo a sequência de opções Templates/Visual 
Basic/Windows.
Procedimentos operacionais
Da mesma maneira que fi zemos no programa anterior, monte um formulário com dois con-
troles TextBox , um controle Button e um controle Label . A Figura 2.9 mostra como pode ser 
defi nido o formulário para esse programa.
O controle Button1 deve ter sua propriedade Text alterada para Somar, e para o controle label1 apa-
gue o texto que está escrito na propriedade Text. Para fazermos isso, basta selecionar o componen-
te Button e na janela Properties localizar a propriedade Text e alterar o texto button1 para Somar 
e aciona a tecla <Enter>.
Figura 2.9 - Programa de soma de dois números.
Esse programa é construído de uma forma um pouco diferente, pois utiliza variáveis . Para que 
uma variável seja usada, devemos primeiramente defi ni-la. É necessário indicar o tipo de dado 
da variável e seu nome de identifi cação.
Com o formulário montado e a janela Form1 ativada, acione com um duplo clique o botão 
Somar e informe o trecho de código indicado a seguir em negrito. A partir deste exemplo 
apresentaremos apenas o trecho de código relacionado ao componente selecionado, não indi-
cando as demais linhas de código geradas automaticamente.
Codificação em Linguagem C#
private void button1_Click(object sender, EventArgs e)
{
 int R, A, B;
 A = Convert.ToInt32(textBox1.Text);
 B = Convert.ToInt32(textBox2.Text);
 R = A + B;
 label1.Text = Convert.ToString(R);
}
3332 Programação de Computadores C#
Dessa forma, está sendo indicado que a rotina de código associada ao componente button1_
Click() trabalha com três variáveis do tipo inteiro. Assim, o compilador reserva, na memória, 
espaço para o armazenamento dos valores fornecidos para cada variável.
Um detalhe a ser observado é o uso das funções de conversão de tipos de dados usadas na entra-
da e na saída de dados: Convert.ToInt32() e Convert.ToString(). Usamos a função Convert.
ToInt32() para converter o dado de entrada que é aceito pelo componente TextBox como uma 
sequência alfanumérica em um dado numérico inteiro. A operação de saída precisa converte o 
dado numérico inteiro em uma sequência alfanumérica, daí o uso da função Convert.ToString().
Após a entrada dos valores numéricos, o programa efetua pela linha de instrução R = A + B 
a soma dos valores fornecidos e atribui o resultado de A + B na variável R, que é em seguida 
apresentada no formulário quando o botão Somar é acionado. Observe que, ao se fazer uso do 
botão Somar, se faz o disparo de um evento, pois ao ser acionado esse botão o evento de soma 
associado ao botão é processado.
Para gravar o projeto, execute o comando FILE/Save All; para verifi car o funcionamento do 
programa execute o comando do menu DEBUG/Start Debugging e aparece a tela do progra-
ma, ou acione a tecla de função <F5>.
Antes de seguirmos em frente, é interessante conhecermos as funções de conversão de tipos 
de dados a serem usadas com programas escritos na linguagem C#. Todas as entradas efetuadas no 
ambiente Visual Studio ocorrem na forma alfanumérica e assim necessitam ser convertidas para o 
tipo de dado em uso. A Tabela 2.3 mostra as principais funções de conversão existentes.
Tabela 2.3 - Funções de Conversão de Tipos de Dados
Função Descrição
Convert.ToString() Converte um dado de qualquer tipo em um dado do tipo string.
Convert.ToInt32() Converte um dado alfanumérico em um dado do tipo inteiro de 32 bits.
Convert.ToInt64() Converte um dado alfanumérico em um dado do tipo inteiro de 64 bits.
Convert.ToInt16() Converte um dado alfanumérico em um dado do tipo inteiro de 16 bits.
Convert.Single() Converte um dado alfanumérico em um dado do tipo real de precisão simples.
Convert.Double() Converte um dado alfanumérico em um dado do tipo real de precisão dupla.
Os dados alfanuméricos a serem convertidos em um formato de dado numérico não podem 
conter em sua sequência caracteres que não sejam números.
Exercício resolvido
Elabore um programa de computador que efetue o cálculo do salário de um profi ssional horista. 
O programa deve solicitar as horas trabalhadas, o valor da hora e o percentual de desconto para 
apresentar o salário bruto, o total de descontos e o salário líquido. Execute o comando FILE/New 
Project, forneça o nome Cap02_Ex03 para o projeto e acione o botão OK. Lembre-se de manter 
selecionada do lado esquerdo a sequência de opções Templates/Visual Basic/Windows.
3332 Programação Sequencial
Procedimentos operacionais
Para construir esse programa é necessário possuir alguns dados, tais como valor da hora de traba-
lho, o número de horas trabalhadas no mês e o percentual de desconto do INSS. O programa em 
questão deve apresentar o valor do salário bruto, o valor descontado e o valor do salário líquido.
A partir do momento em que o novo formulário é aberto, vamos atribuir um novo nome para 
esse componente. Selecione na janela Properties a propriedade Text do formulário e informe o 
título Cálculo de Salário Líquido. Em seguida, arraste a borda direita da janela para que o texto 
do título seja apresentado por inteiro. A Figura 2.10 mostra essa ocorrência.
Figura 2.10 - Alteração para Cálculo de Salário Líquido.
A seguir, com base na Figura 2.11, vamos construir a parte visual da aplicação. Observe deta-
lhadamente os componentes inseridos e siga as instruções indicadas a seguir.
Figura 2.11 - Aparência final do formulário.
Selecione na barra de ferramentas Toolbox o controle de saída de dados Label. Coloque-o no 
canto superior esquerdo e altere a propriedade Text desse controle para Quantas horas de tra-
balho?. Em seguida, coloque um segundo controle Label, logo abaixo do primeiro. Altere seu 
Text para Qual o valor da hora?. Agora, é colocado o terceiro controle Label, logo abaixo do 
segundo. O Text desse rótulo é Qual o percentual de desconto?.
A partir do momento em que os controles Label estão inseridos, é necessário colocar os con-
troles de edição para cada mensagem. Selecione um controle TextBox e coloque um à frente de 
cada rótulo. Devem ser colocados três controles TextBox.
3534 Programação de Computadores C#
É necessário inserir um botão abaixo dos rótulos e dos componentes TextBox. Altere a pro-
priedade Text para Salário Líquido. É preciso aumentar o tamanho horizontal do botão para 
que o texto seja apresentado de forma completa. Isso é conseguido arrastando a alça de seleção 
do controle com o ponteiro do mouse.
Abaixo do componente Buttom insira do lado esquerdo três componentes do tipo Label com 
as propriedades Text definidas para: Salário bruto, Total de desconto e Salário líquido. Em 
seguida, do lado direito, insira três componentes do tipo Label alinhados aos três últimos 
componentes inseridos.
Com a janela Cálculo de Salário Líquido ativa, acione com um duplo clique o botão Salário 
Líquido e acrescente o trecho de código indicado em negrito a seguir.
Codificação em Linguagem C#
private void button1_Click(object sender, EventArgs e)
{
 float HT, VH, PD, TD, SB, SL;
 HT = Convert.ToSingle(textBox1.Text);
 VH = Convert.ToSingle(textBox2.Text);
 PD = Convert.ToSingle(textBox3.Text);
 SB = HT * VH;
 TD = (PD / 100) * SB;
 SL = SB - TD;
 label7.Text = Convert.ToString(SB);
 label8.Text = Convert.ToString(TD);
 label9.Text = Convert.ToString(SL);
}
As variáveis HT, VH, PD, TD, SB e SL representam,respectivamente, Hora Trabalhada, Valor 
da Hora, Percentual de Desconto, Total de Desconto, Salário Bruto e Salário Líquido.
Ao fazer a execução do programa, valores do tipo real são separados por vírgula nos campos 
de entrada como separador de valores numéricos. No entanto, no código de programa é neces-
sário usar ponto para separar o expoente da mantissa do número real.
O programa anterior pode apresentar os valores de saída com visual melhorado. Para tanto usare-
mos o método ToString() associado à variável a ser apresentada com o código de formatação dese-
jado. Assim, vamos alterar as três últimas linhas do código do programa como indicado a seguir.
private void button1_Click(object sender, EventArgs e)
{
 float HT, VH, PD, TD, SB, SL;
 HT = Convert.ToSingle(textBox1.Text);
 VH = Convert.ToSingle(textBox2.Text);
 PD = Convert.ToSingle(textBox3.Text);
 SB = HT * VH;
 TD = (PD / 100) * SB;
 SL = SB - TD;
 label7.Text = Convert.ToString(SB.ToString("##,##0.00"));
 label8.Text = Convert.ToString(TD.ToString("##,##0.00"));
 label9.Text = Convert.ToString(SL.ToString("##,##0.00"));
}
3534 Programação Sequencial
O método ToString() permite formatar uma saída numérica. Nesse caso, usa-se o formato 
##,##0.00 que apresenta valores do tipo real no formato 99.999,99. O símbolo # (tralha) deter-
mina que, na ausência de um número, nada será apresentado; onde está o símbolo 0 (zero), se 
não houver valor, o valor zero será colocado nessa posição, e o símbolo . (ponto) é usado para 
separar a mantissa (parte decimal) do expoente de um valor numérico; o símbolo , (vírgula) 
determina a separação da casa de milhares de um valor numérico.
Para gravar o projeto, execute o comando FILE/Save All. 
O método ToString() pode usar outros parâmetros de formatação como (%) porcentagem para 
apresentação de valores como percentuais, sendo o valor com esse símbolo apresentado mul-
tiplicado por 100; (E) para valores em formatação de notação científica (E0, E+0, E-0, E0, e+0, 
e-0); (\) barra invertida para uso de caracteres de escape; ("ABC") para formatação de cadeias 
de caracteres e (;) para separação de grupos de valores positivos e negativos.
Para gravar o projeto, execute o comando FILE/Save All e, para verificar o funcionamento do 
programa, execute o comando do menu DEBUG/Start Debugging e aparece a tela do progra-
ma ou acione a tecla de função <F5>.
Em relação à barra invertida, é possível usar alguns caracteres de controle escape. Observe a 
seguinte Tabela 2.3 com alguns deles.
Tabela 2.4 - Códigos de controle de escape
Código Finalidade
\n Gera uma nova linha.
\t Gera um espaço de tabulação.
\b Executa um retrocesso de espaço.
\" Apresenta o símbolo de aspas inglesas.
\' Apresenta o símbolo de aspas simples.
\\ Apresenta o símbolo de barra invertida.
\f Ocasiona um salto de página de formulário (uso de uma impressora).
\0 Gera um nulo.
\a Cria sinal de alerta (campainha do sistema).
\r Gera o sinal de retorno de carro.
2.8 Tabulação de componentes
Ao desenvolvermos a montagem de um formulário, é necessário tomarmos o devido cuidado 
na colocação dos componentes em relação à sua ordem.
A ordem de inserção de um componente influencia no seu funcionamento, quando se utiliza a 
tecla <Tab> para efetuar os avanços nesses componentes.
AT36 Programação de Computadores C#
É ideal, sempre que houver dúvida, verifi car o valor numérico da propriedade TabIndex de um 
componente na janela Properties.
Feche o ambiente integrado Visual Basic com o comando de menu File/Exit ou pressione as 
teclas de atalho <Alt> + <F4>.
Neste capítulo foram descritos o uso de tipos de dados, variáveis, constantes, operadores aritméti-
cos, expressões aritmética, ações de entrada e saída, processamento matemático e manipulação de valores.
Vamos recapitular?
Agora é com você!
1) Calcular a quantidade de litros de combustível gasta em uma viagem, utilizando um 
automóvel que faz 12 km por litro. Para o cálculo, o usuário deve fornecer o tempo gas-
to na viagem e a velocidade média. Dessa forma, é possível obter a distância percorrida 
com a fórmula DISTANCIA = TEMPO * VELOCIDADE. Tendo o valor da distância, 
basta calcular a quantidade de litros de combustível utilizada na viagem com a fórmu-
la LITROS_USADOS = DISTANCIA / 12. O programa deve apresentar os valores da 
velocidade média, o tempo gasto, a distância percorrida e a quantidade de litros utiliza-
da na viagem. Sugestão: trabalhe com valores reais.
2) Ler uma temperatura em graus Celsius e apresentá-la convertida em graus Fahrenheit. 
A fórmula de conversão a ser utilizada pode ser F = (9 * C + 160) / 5, em que a variá-
vel F representa a temperatura em graus Fahrenheit e a variável C é a temperatura em 
graus Celsius.
3) Ler uma temperatura em graus Fahrenheit e apresentá-la convertida em graus Celsius. 
A fórmula de conversão a ser utilizada pode ser C = ((F – 32) * 5) / 9, em que a variável 
F é a temperatura em graus Fahrenheit e a variável C é a temperatura em graus Celsius.
4) Calcular e apresentar o valor do volume de um galão (uma lata) de óleo, utilizando a 
fórmula V = 3.14159 * R * R * H, em que as variáveis V, R e H representam, respecti-
vamente, o volume, o raio e a altura do galão.
5) Ler dois valores inteiros para as variáveis A e B, trocar os valores de modo que a variá-
vel A passe a ter o valor da variável B e a variável B passe a ter o valor da variável A. 
Apresentar o resultado da troca solicitada.
37AT
3
Programação 
com Desvios
Este capítulo apresenta os detalhes sobre o uso de tomadas de decisão em programação no esta-
belecimento de processamento lógico. São apresentados os conceitos de condição, decisão, operadores 
relacionais, operadores lógicos, decisão simples, decisão composta, decisão seletiva e divisibilidade. 
Para começar
3.1 Decisões, condições e operadores relacionais
Para um programa de computador tomar decisões, é necessário criarmos para ele uma condi-
ção . Assim, para tomar uma decisão, é necessário existir uma condição. Uma condição pode produ-
zir uma de duas respostas: pode ser uma resposta verdadeira ou uma resposta falsa.
A condição, por sua vez, do ponto de vista condicional, é a defi nição de relação lógica entre 
variáveis versus variáveis ou variáveis versus constantes defi nidas com o uso de operadores relacio-
nais. A relação lógica existente entre os elementos de uma condição é conseguida com a utilização 
dos operadores relacionais , de acordo com o que mostramos na Tabela 3.1.
3938 Programação de Computadores C#
Tabela 3.1 - Operadores relacionais
Símbolo Significado
== igual a 
! = diferente de (não igual)
> maior que 
< menor que 
>= maior ou igual que 
<= menor ou igual que 
São condições válidas as seguintes estruturas relacionais: A == B, A ! = B, A > B, A < B, A >= B, 
A <= B ou A == 5, A != 5, A > 5, A < 5, A >= 5, A <= 5.
A partir do momento que temos uma condição, pode-
mos em um programa estabelecer ações de desvios condicio-
nais. Os desvios condicionais estão associados à utilização de 
decisões em um programa de computador. Uma decisão a ser 
tomada, como já comentado, pode ser verdadeira ou falsa. Se 
verdadeira, determinada ação pode ser executada; se falsa, 
outra ação pode ou não ser executada. Portanto, um desvio 
condicional pode ser simples ou composto.
3.2 Desvio condicional simples
Um desvio condicional será simples quando tivermos uma condição que desvia a execução do 
programa caso o resultado lógico avaliado de certa condição seja verdadeiro. Se o resultado lógico 
avaliado for falso, nada acontecerá, e o programa simplesmente segue o seu fl uxo de execução.
Um desvio condicional simples , nas linguagens de programação C e C++, é realizado por meio 
da instrução if , que possui a seguinte sintaxe:
if <(condição )> 
{
 <instrução 1 executada quando condição for verdadeira>;
 <instrução 2 executada quando condição for verdadeira>;
 <instrução N executada quando condição for verdadeira>;