Programação de Computadores C# PDF

Programação de Computadores C#
José Augusto N. G. Manzano
Programação de Computadores C#
1ª Edição
1
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-02404CDD-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 Programação de Computadores C#
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.
3
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.
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
5
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
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.
7
» 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 definiçã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í-
ficos 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 polimorfismo.
Espero que este trabalho seja útil não só ao aluno, mas também para o professor.
Um abraço a todos!
O autor
1
Introdução
Para começar
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.
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 software.
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.
9
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.
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 O termo paradigma, muito usado na área
.NET Framework, que é o ambiente que contém as bibliotecas de programação de computadores, se
refere na verdade ao uso de um modelo,
necessárias à execução da CLR e do código de aplicação.
uma forma, a ser seguido.
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- Atualmente, a atividade de programa-
ção de computadores está em diversos
mação. Além do Visual C#, encontramos nesse ambiente as
equipamentos eletrônicos de todos os
linguagens Basic (Visual Basic .NET) e C++ (Visual C++) for- tamanhos.
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.
Introdução 11
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.
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”.
Introdução 13
É 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.
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 Toolbox e 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.
Introdução 15
O cenário para a área de software 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ífico. 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.
Amplie seus conhecimentos
A linguagem Java, orientada a objetos, criada em 1991 na Sun Microsystems, é a principal concorrente direta da lingua-
gem C#.
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 definir 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 modificações) em outro computador.
As linguagens de segunda geração, na sua maioria, são lineares, e identificam seus comandos
com linhas numeradas. Essa característica dificulta a adoção de técnicas estruturadas de codificação
de programa. Não que essas linguagens não permitam o uso da técnica, apenas dificultam um pouco,
o que leva programadores inexperientes a cometerem verdadeiros absurdos na codificaçã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 definiçã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,
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
Introdução 17
voltados para necessidades específicas em que a parte gráfica não é um requisito operacional neces-
sário. A parte gráfica é 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 bolo e esquecem o bolo. Concentrar nossos esforços somente na parte gráfica 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áfico, nos dá dois pontos de atenção, sendo a
interface gráfica 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áfico exige de nós atenção em dois pontos
essenciais do programa: a parte gráfica e o código associado à parte gráfica (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áfico, 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íficas e nossa atenção estará voltada ao entendimento dessas instruções.
Vamos recapitular?
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.
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.
2
Programação
Sequencial
Para começar
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.
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 predefinidos, classificados em: numé-
rico inteiro, numérico de ponto flutuante,1 caractere e lógico. Os tipos de dados são usados a fim de alocar
espaço de memória para armazenamento e manipulação de valores de trabalho de um programa.
1 Ponto flutuante (notação científica) é 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.
19
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
de -32.768
short 16 bits
até 32.767
de 0
ushort 16 bits
até 65.535
de -2.147.483.648
int 32 bits
até 2.147.483.647
de 0
uint 32 bits
até 4.294.967.295
de -9.223.372036.854.775.808
long 64 bits
até 9.223.372036.854.775.807
de 0
ulong 64 bits
até 18.446.744.073.709.551.615
de -3.4028235e38
float 32 bits
até 3.4028235e38
de -1.79769313486231e308
double 64 bits
até 1.79769313486231e308
de 0
decimal 128 bits
até +/-79.228.162.514.264.337.593.543.950.335
de 0
byte 8 bits
até 255
de -128
sbyte 8 bits
até 127
de 0 caractere
char 16 bits
até 65.535 caracteres
de 0 caractere
string 16 bits
até 2.000.000.000 caracteres aproximados
falso (False ou 0)
bool 16 bits
verdadeiro (True ou qualquer valor numérico)
Referência feita a variáveis instanciadas a partir de um

object 32 bits
objeto
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.
Fique de olho!
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
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.
Programação Sequencial 21
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, de valor 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 -
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:
b⋅h
A =
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
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.
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
bloco operacional, 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.
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.
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.
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 fixada 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 fixada 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á fixado
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 ficar a sua área de trabalho (desktop).
Figura 2.5 - Controle TextBox, Figura 2.6 - Controle Button,
inserido no formulário Form1. 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
Figura 2.7 - Controle Label1,
do programa. Na janela apresentada, escreva apenas inserido no formulário Form1.
a linha de código indicada a seguir em negrito:
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
{
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 clique no 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.
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.
Da mesma maneira que fizemos 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
definido 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 defini-la. É necessário indicar o tipo de dado
da variável e seu nome de identificaçã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.
{
int R, A, B;
A = Convert.ToInt32(textBox1.Text);
B = Convert.ToInt32(textBox2.Text);
R = A + B;
label1.Text = Convert.ToString(R);
}
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 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>.
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.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.
Elabore um programa de computador que efetue o cálculo do salário de um profissional 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.
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.
É 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.
{
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.
{
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"));
}
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.
É ideal, sempre que houver dúvida, verificar 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>.
Vamos recapitular?
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.
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.
3
Programação
com Desvios
Para começar
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.
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 definição de relação lógica entre
variáveis versus variáveis ou variáveis versus constantes definidas 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.
37
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 A palavra informática significa infor-
decisões em um programa de computador. Uma decisão a ser mação automatizada. Esse termo está
associado à ação de processar dados.
tomada, como já comentado, pode ser verdadeira ou falsa. Se Para saber mais, consulte o site http://
verdadeira, determinada ação pode ser executada; se falsa, escolainformaticablog.wordpress.com/
outra ação pode ou não ser executada. Portanto, um desvio 2013/01/04/o-significado-da-palavra-
condicional pode ser simples ou composto. -informatica/ (fev/2014).
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 fluxo 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 N executada quando condição for verdadeira>;
}
<instrução executada após condição ser verdadeira e/ou falsa>;
Elabore um programa que leia dois valores numéricos inteiros, some-os e apresente o resulta-
do, caso o valor somado seja maior que 10. Execute o comando FILE/New Project, forneça o
nome Cap03_Ex01 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.
Vamos preparar o formulário para o programa. A primeira ação é proceder à mudança da pro-
priedade Text do formulário para Decisão Simples.
Em seguida, vamos inserir dois controles Label, um embaixo do outro, tendo o primeiro sua
propriedade Text alterada para Entre um valor para a posição A: e o segundo, a propriedade
Text alterada para Entre um valor para a posição B:.
Na sequência, devemos inserir dois controles TextBox, um ao lado de cada controle label, não
necessitando alterar sua propriedade Text. Vamos inserir também um controle Button e abaixo
colocar um componente Label. Ajuste o tamanho da janela Form1 de modo que fique seme-
lhante à Figura 3.1.
Figura 3.1 - Formulário com rótulos, campos de edição e botão.
Vamos alterar a propriedade Text do controle button1 para Processar.

A partir do formulário pronto, é necessário preparar o processamento do cálculo. Para tan-
to, vamos acionar o botão Processar do formulário e informe dentro da rotina apresentada as
linhas seguintes grafadas em negrito:

{
int R, A, B;
R = A + B;
if (R > 10)
{
Label3.Text = Convert.ToString(R);
}
}
Programação com Desvios 39

Se forem fornecidos os valores 4 e 6, nada será apresentado. Caso sejam fornecidos os valores 5
e 7, o resultado apresentado será 12.
Para gravar o projeto, execute o comando FILE/Save All; para executar o programa, use o
comando de menu DEBUG/Start Debugging.
Após a definição dos tipos de variáveis, é solicitada a leitura dos dois valores implicados pelas
variáveis A e B. Depois, é efetuada a adição das variáveis A e B, o que é implicado pela variável R.
Nesse ponto, por meio de uma condição inserida na instrução if, o programa verifica se é possível
apresentar o resultado da adição, caso ele seja maior que 10; não sendo, o programa não apresenta
absolutamente nada. Note os delimitadores { e } que definem o bloco de ação condicional subordi-
nado à condição que determinamos.
3.3 Desvio condicional composto

Vimos anteriormente como usar a instrução if simples para avaliar determinada condição
(desvio condicional simples). Agora, será explicado como usar a instrução if... else. Numa instrução
If... else, se a condição for verdadeira, será executada a instrução posicionada entre as instruções if e
else. Sendo a condição falsa, será executada a instrução posicionada logo após a else, como é indi-
cado na seguinte sintaxe:
if <(condição)>
{
<instrução N executada quando condição for verdadeira>;
}
else
{
<instrução 1 executada quando condição for falsa>;
<instrução 2 executada quando condição for falsa>;
<instrução N executada quando condição for falsa>;
}
<instrução executada após condição ser verdadeira ou falsa>;
Elabore um programa que faça a leitura de dois valores numéricos inteiros e sua adição. Caso
o resultado obtido seja maior ou igual a 10, esse valor deve ser apresentado, somando a ele
5. Caso o resultado do valor somado não seja maior ou igual a 10, ele deve ser apresentado
subtraindo 7. Execute o comando FILE/New Project, forneça o nome Cap03_Ex02 para o pro-
jeto e acione o botão OK. Lembre-se de manter selecionada do lado esquerdo a sequência de
opções Templates/Visual Basic/Windows.
O formulário deste exemplo será bastante
semelhante aos demais, com exceção da apre-
sentação do resultado, que será feita com uma
caixa de mensagem, e não em um controle
Label. A Figura 3.2 apresenta o modelo do for-
mulário. Siga o modelo da figura e crie um for-
mulário semelhante.
Na sequência, acione o botão Processar, para
que seja escrito na rotina o código em negrito
apresentado a seguir:
Figura 3.2 - Formulário para o terceiro exemplo.

{
int R, X, A, B;
X = A + B;
if (X >= 10)
{
R = X + 5;
MessageBox.Show("R = " + R.ToString(), "Resultado V");
}
else
{
R = X - 7;
MessageBox.Show("R = " + R.ToString(), "Resultado F");
}
textBox1.Focus();
}
Se forem fornecidos os valores 4 e 5, o resultado apresentado será 2. Caso sejam fornecidos os

valores 5 e 7, o resultado apresentado será 17. A instrução textBox1.Focus() tem por finalidade
voltar o foco do cursor para dentro do campo do componente textBox1.
O programa anterior usa a instrução MessageBox.Show() para apresentar a saída do programa.

A caixa de mensagem gerada pela instrução MessageBox.Show() apresenta uma mensagem dentro
de uma caixa com um botão OK. Note que foi feita a concatenação do resultado da operação com a
mensagem que será exibida pelo recurso, com o uso do método ToString(), que converte um valor
numérico em um valor string. A funcionalidade MessageBox.Show() possui a seguinte sintaxe:

MessageBox.Show(MSG, TIT, BOT, ICO, PAD, ALI);
em que:
»» MSG: é a mensagem de saída que será exibida dentro da caixa de mensagem.
»» TIT: é a mensagem de identificação do título a ser exibida na barra de título da caixa de
mensagem.
»» BOT: é uma constante interna que identifica os tipos de botões a serem apresentados na
caixa de mensagem (tabela mais adiante).
»» ICO: é uma constante interna que identifica os tipos de ícones a serem apresentados na
caixa de mensagem (tabela mais adiante).
»» PAD: é uma constante interna que identifica qual dos botões apresentados estará selecio-
nado com execução de ação-padrão (tabela mais adiante).
»» ALI: é uma constante interna que permite escrever uma mensagem ao lado direito da
caixa. Esse parâmetro normalmente não é usado (tabela mais adiante).
Os parâmetros podem ser omitidos desde que não haja omissões de parâmetros intermediá-
rios. Por exemplo, podem ocorrer as seguintes combinações: só MSG; só MSG, TIT; só MSG, TIT,
BOT; só MSG, TIT, BOT, ICO; só MSG, TIT, BOT, ICO, PAD e por fim só MSG, TIT, BOT, ICO,
PAD, ALI. Combinação do tipo MSG, BOT, PAD não é aceita.
A Tabela 3.2 descreve cada constante que pode ser fornecida como argumento para formata-
ção de uma caixa de mensagem.
Tabela 3.2 - Constantes utilizadas com o recurso MessageBox.Show()
Tipo de botão Constante
Apresenta o botão OK por padrão quando esse valor é omitido. MessageBoxButtons.OK
Mostra os botões OK e Cancelar. MessageBoxButtons.OKCancel
Apresenta os botões Anular, Repetir e Ignorar. MessageBoxButtons.AbortRetryIgnore
Exibe os botões Sim, Não e Cancelar. MessageBoxButtons.YesNoCancel
Apresenta os botões Sim e Não. MessageBoxButtons.YesNo
Indica os botões Repetir e Cancelar. MessageBoxButtons.RetryCancel
MessageBoxIcon.Error ou
Exibe o ícone de advertência: a letra “x” branca no interior de
MessageBoxIcon.Hand ou
um círculo vermelho.
MessageBoxIcon.Stop
Exibe o ícone de questionamento: o ponto de interrogação

MessageBoxIcon.Question
branco no interior de um balão azul.
MessageBoxIcon.Warning ou
Exibe o ícone de atenção: o ponto de exclamação preto no
interior de um triângulo amarelo.
MessageBoxIcon.Exclamation
MessageBoxIcon.Information ou
Exibe o ícone de informação: a letra “I” branca no interior de
um balão azul.
MessageBoxIcon.Asterisk
Tipo de botão Constante
Não exibe nenhum ícone, sendo essa a forma-padrão quando

MessageBoxIcon.None
é omitido.
Determina qual dos botões será marcado como botão-padrão.

MessageBoxDefaultButton.ButtonN
Deve ser substituído o “N” pelo número do botão desejado.
Determina o alinhamento à direita para a mensagem e o título

MessageBoxOptions.RightAlign
da caixa de mensagem.
Note as possibilidades de combinação de uso, obtidas pelo método Show() da estrutura

MessageBox, de acordo com alguns dos seus parâmetros. A Figura 3.3 mostra, da esquerda para
a direita e de cima para baixo, os exemplos conseguidos a partir dos seguintes trechos de códigos.
Os códigos apresentados podem ser escritos da forma apresentada ou no sentido horizontal. Para
executá-los, basta colocar em um formulário dentro de um controle Button e acrescentar o trecho de
código à instrução MessageBox.Show();.

{
MessageBox.Show
(
"Mensagem",
"TÍtulo"
);
}

{
MessageBox.Show
(
"Mensagem",
"TÍtulo",
MessageBoxButtons.OKCancel
);
}

{
MessageBox.Show
(
"Mensagem",
"TÍtulo",
MessageBoxButtons.AbortRetryIgnore
);
}

{
MessageBox.Show
(
"Mensagem",
"TÍtulo",
MessageBoxButtons.YesNoCancel
);
}

{
MessageBox.Show
(
"Mensagem",
"TÍtulo",
MessageBoxButtons.YesNo
);
}

{
MessageBox.Show
(
"Mensagem",
"TÍtulo",
MessageBoxButtons.RetryCancel
);
}

{
MessageBox.Show
(
"Mensagem",
"TÍtulo",
MessageBoxButtons.OK,
MessageBoxIcon.Error
);
}

{
MessageBox.Show
(
"Mensagem",
"TÍtulo",
);
}

{
MessageBox.Show
(
"Mensagem",
"TÍtulo",
MessageBoxIcon.Warning
);
}

{
MessageBox.Show
(
"Mensagem",
"TÍtulo" ,
MessageBoxIcon.Information
);
}
Figura 3.3 - Exemplos de uso MessageBox.Show().
Elabore um programa que tenha em um formulário apenas um componente Button para que,
quando acionado, apresente em uma caixa de mensagem a pergunta “Você é honesto?” com
os botões Sim e Não. Ao ser selecionado o botão Sim deve ser apresentada outra caixa de diá-
logo com a mensagem “Parabéns!!!”, com o botão OK. Se selecionado o botão Não, deve ser
apresentada uma caixa de mensagem com o texto “Seu pilantra!!!” com o botão OK. Execute o
Basic/Windows.
Insira no formulário um controle Button, acione esse controle com um duplo clique e escreva
o código a seguir indicado em negrito.

{
DialogResult RESP;
RESP = MessageBox.Show
(

"Você é honesto?",
"Uma Pergunta",
MessageBoxButtons.YesNo,
);
if (RESP == DialogResult.Yes)
{
MessageBox.Show
(
"Parabéns!!!",
"Respondeu SIM",
);
}
else
{
MessageBox.Show
(
"Seu pilantra!!!",
"Respondeu NÃO",
MessageBoxIcon.Error
);
}
}
A função Show() da estrutura MessageBox é usada com a atribuição à variável RESP do tipo
enumerado DialogResult. Dessa forma, ao acionar um dos botões apresentados, captura-se o
valor da constante de sua operação. No caso do acionamento do botão Sim (Yes), o valor cap-
turado é DialogResult.Yes. Olhe o trecho da instrução if (RESP == DialogResult.Yes). Se for
acionado o botão Sim, a condição é verdadeira e se faz a apresentação da primeira mensagem;
caso contrário, será apresentada a segunda mensagem.
O tipo enumerado DialogResult disponibiliza como constantes de captura de ações de botões,
além do valor Yes, os valores Abort, Cancel, Ignore, No, None, OK e Retry.
As Figuras 3.4, 3.5 e 3.6 mostram as telas que aparecem quando da execução do programa.
Figura 3.4 - Pergunta Figura 3.5 - Ação para Figura 3.6 - Ação para
a ser executada. condição verdadeira. condição verdadeira.
Vamos aproveitar para ver uma ocorrência que pode acontecer no uso de tomadas de decisão,
tanto simples quanto compostas. Há situações que podem ocasionar o uso de decisões que sejam
sequenciais, ou seja, quando um conjunto de decisões é definido uma após a outra. Pode ainda haver
a situação de encadeamento de tomadas de decisão, quando uma decisão, para ser tomada, depende
de outra decisão anterior. Nesse sentido, o próximo exemplo demonstra esse tipo de situação.
Elabore um programa que apresente uma pequena calculadora para as quatro operações arit-
méticas básicas. O programa deve aceitar a entrada de apenas dois valores numéricos reais,
apresentar as operações para seleção e mostrar o resultado quando o botão de cálculo for acio-
nado. Execute o comando FILE/New Project, forneça o nome Cap03_Ex05 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.
Para estabelecermos o conjunto de opções das operações aritméticas, usaremos para este pro-
grama o componente de botão de rádio que permite selecionar uma opção de uma lista defini-
da. A Figura 3.7 mostra o formulário que será usado pelo programa.
O formulário deve ter a sua proprie-

dade Text com o texto CalcSim - Cal-
culadora Simples. Tome o cuidado de
inserir os dois controles TextBox supe-
riores um abaixo do outro. Observe
também que o tamanho do formulário
do programa foi um pouco diminuído.
Acrescente um controle TextBox no
canto inferior direito.
Figura 3.7 - Formulário do programa Calculadora.
No formulário, é usado um controle novo, denominado RadioButton. Insira quatro controles

desse tipo de forma que o controle radioButton1 tenha seu Text alterado para o texto Adição, o
controle radioButton2 tenha seu Text alterado para o texto Subtração, o controle radioButton3
tenha seu Text alterado para o texto Multiplicação e o controle radioButton4 tenha seu Text
alterado para o texto Divisão.
O outro controle é um Button com sua propriedade Text alterada para Calcular colocado no
canto inferior esquerdo.
Em relação ao terceiro controle TextBox (textBox3), serão feitas algumas alterações em suas
propriedades. Assim, selecione-o e localize na janela Properties a propriedade Locked, alteran-
do-a para True. Dessa forma, esse controle somente terá a capacidade de apresentar um valor,
não permitindo a sua alteração. Como será utilizada para apresentar o resultado da operação,
essa alteração se torna conveniente. Outra alteração é com a propriedade TabStop alterada
para False. Dessa forma, se você utilizar a tecla <Tab> para movimentar o foco nos controles
do formulário, ele estará inibido.

O controle button1, que deve estar com seu Text alterado para Calcular, deve ter o código em
negrito, indicado em seguida.

{
float R = 0, A, B;
A = Convert.ToSingle(textBox1.Text);
B = Convert.ToSingle(textBox2.Text);
R = A + B;
if (radioButton1.Checked)
{
R = A + B;
}
{
R = A - B;
}
{
R = A * B;
}
{
if (B == 0)
{
MessageBox.Show("ERRO – Divisão zero!");
}
else
{
R = A / B;
}
}
textBox3.Text = R.ToString();
textBox1.Focus();
}
O programa anterior apresenta uma sequência de instruções do tipo if, uma após outra, e cada
uma delas verifica se o botão de opção está ativo. Isso feito, é verificado se o seu valor é verda-
deiro; em sendo, a operação é então efetuada.
Execute alguns testes com valores inteiros e de pontos flutuantes. Perceba que na instrução if
(radioButton4.Checked) se encontra uma segunda decisão encadeada, verificando se o valor
da variável B é 0 (zero). A ser verdadeira essa condição, é apresentada uma mensagem de erro.
Essa decisão foi usada para evitar que uma mensagem de erro do programa fosse apresentada
quando da divisão de um número por zero, gerando a sua interrupção.
3.4 Desvio condicional seletivo
Ao trabalharmos com grande quantidade de desvios condicionais, poderemos ter um pro-
grama de difícil interpretação, e para auxiliar e facilitar esse tipo de necessidade temos a estrutura de
controle com múltipla escolha, denominada switch, cuja sintaxe é:
switch <variável>
{
case <opção 1>: <operação 1>; break;
case <opção 2>: <operação 2>; break;
case <opção N>: <operação N>; break;
default : <operação default>; break;
}
em que:
» <variável> - nome da variável a ser controlada na decisão;
» <opção> - conteúdo da variável a ser verificado;
» <operação> - execução de alguma ação específica.
A instrução default da estrutura de seleção switch e qualquer operação a ela associada são
opcionais, não caracterizando obrigatoriedade de uso. A instrução break tem a finalidade de desviar
o processamento para fora do comando switch. Isso é necessário porque após o processamento de
cada case ocorre retorno do fluxo de ação do comando para a primeira instrução após sua chamada,
que nesse caso será break.
A variável usada numa estrutura switch para controlar a ação desse tipo de desvio na lingua-
gem C# pode operar com variáveis do tipo inteiro ou cadeia.
Elabore um programa que solicite a entrada de um valor numérico inteiro entre 1 e 12 e apre-
sente o nome do mês por extenso. Execute o comando FILE/New Project, forneça o nome
Cap03_Ex06 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.
No formulário, altere a propriedade Text para Meses. Insira quatro componentes, sendo: dois
Textbox, um Bottom com propriedade Text definida como “Processar” e um Label com pro-
priedade Text definida como “Informe um valor de 1 a 12:”. O componente textBox1 deve ficar
ao lado direito do componente Label e o componente textBox2 (posicionado ao lado direito do
botão Processar) é utilizado para dar a saída de uma informação. Ele terá algumas de suas pro-
priedades alteradas. Uma vez selecionado, localize na janela Properties a propriedade Locked,
alterando-a para True, e selecione a propriedade TabStop, alterando-a para False. A Figura 3.8
mostra o formulário que será usado pelo programa.

Figura 3.8 - Formulário do programa Meses.
O componente button1 identificado como Processar deve ser acionado com um duplo clique e
receber o seguinte código em negrito.

{
int MES;
MES = Convert.ToInt32(textBox1.Text);
switch (MES)
{
case 1: textBox2.Text = "Janeiro"; break;
case 2: textBox2.Text = "Fevereiro"; break;
case 3: textBox2.Text = "Marco"; break;
case 4: textBox2.Text = "Abril"; break;
case 5: textBox2.Text = "Maio"; break;
case 6: textBox2.Text = "Junho"; break;
case 7: textBox2.Text = "Julho"; break;
case 8: textBox2.Text = "Agosto"; break;
case 9: textBox2.Text = "Setembro"; break;
case 10: textBox2.Text = "Outubro"; break;
case 11: textBox2.Text = "Novembro"; break;
case 12: textBox2.Text = "Dezembro"; break;
default: textBox2.Text = "Mes invalido"; break;
}
textBox1.Clear();
textBox1.Focus();
}
A instrução textBox1.Clear() tem por finalidade proceder à limpeza do conteúdo do controle

TextBox indicado.
O comando switch é útil apenas nos casos em que a tomada de decisão sequencial ou encadea-
da faz uso de condições que estejam baseadas no operador relacional “igual a”.
Outro detalhe a ser considerado é que o comando default na estrutura de tomada de decisão
seletiva é opcional. Ele pode ser omitido quando não se desejar definir uma ação por as condi-
ções gerais não terem sido satisfeitas.
3.5 Operadores lógicos
Em algumas ocasiões, é necessário trabalhar com o relacionamento de duas ou mais condições
ao mesmo tempo e na mesma instrução if, para que seja tomada uma única decisão, realizando tes-
tes múltiplos. Para esses casos, usamos operadores lógicos, em que: && (e - operador de conjunção),
|| (ou - operador de disjunção inclusiva) e ! (não - operador de negação).
Nesta etapa de nosso estudo, vamos apresentar os programas para teste dos operadores lógicos
em modo console. Dessa maneira temos uma visão de alguns novos comandos, tais como:
»» Console.ReadLine() – efetua entrada de dado na variável indicada;
»» Console.Write() – efetua a saída de algum dado no monitor de vídeo mantendo o cursor
na mesma linha;
»» Console.WriteLine() – efetua a saída de dados no monitor de vídeo avançando o cursor
para a próxima linha;
»» Console.ReadKey() – efetua uma pausa e aguarda que alguma tecla seja acionada no teclado;
»» Console.Clear() – efetua a limpeza do monitor de vídeo.
A estrutura de escrita de um programa em modo console é um pouco diferente da estrutura
de escrita de um programa em modo gráfico. Não entraremos em pormenores, pois o foco do nosso
estudo é a parte gráfica. Fica aqui esta apresentação apenas como uma ilustração do uso desse modo
de trabalho.
Para fazermos uso do modo console, a criação de um projeto segue alguns passos diferentes.
Assim, execute o comando FILE/New Project, selecione na caixa de diálogo New Project a opção
Console Application, informe no campo Name o nome do projeto e acione o botão OK. Lembre-se
de manter selecionada do lado esquerdo a opção Templates/Visual C#/Windows.
Precisamos estar atentos ao fato de selecionar Console Application quando desejamos progra-
mar em modo console e selecionar Windows Forms Application quando desejamos programar em
modo gráfico.
Os operadores lógicos && e || permitem mais de uma condição para a tomada de uma única
decisão. Já o operador lógico ! tem por finalidade a negação do estado lógico de uma condição. Para
usar adequadamente os operadores lógicos em expressões lógicas, é necessário levarmos em consi-
deração a ordem de precedência. A Tabela 3.3 nos mostra a precedência de operadores lógicos.
Tabela 3.3 - Precedência de uso dos operadores lógicos
Tabela de precedência de operadores lógicos
Operador Operação Precedência
! Negação 1
&& Conjunção 2
|| Disjunção 3

A tabela de precedência dos operadores lógicos indica a prioridade de execução em uma
expressão lógica. O operador ! é o que possui maior nível de prioridade, portanto deve ser executado
primeiro. Num segundo momento, tem-se o operador lógico &&, que possui médio nível de priori-
dade, e, por último, o operador || , com baixo nível de prioridade.
3.5.1 Operador lógico de conjunção

O operador lógico de conjunção && é utilizado quando dois ou mais relacionamentos lógicos
de uma condição são verdadeiros. Veja a Tabela 3.4.
Tabela 3.4 - Tabela verdade para o operador lógico de conjunção
Condição 1 Condição 2 Resultado
Falsa Falsa Falso
Verdadeira Falsa Falso
Falsa Verdadeira Falso
Verdadeira Verdadeira Verdadeiro
O operador && faz com que determinada operação seja executada somente se todas as condições
mencionadas forem simultaneamente verdadeiras, gerando, assim, um resultado lógico verdadeiro.
Elabore um programa em que, com a utilização do operador de conjunção and, a mensa-
gem O valor está entre 20 e 90 somente será apresentada se o valor fornecido para a variável
NUMERO estiver entre 20 e 90. Qualquer valor fornecido fora da faixa definida apresenta a
mensagem O valor não está entre 20 e 90. Execute o comando FILE/New Project, selecione na
caixa de diálogo New Project a opção Console Application, informe no campo Name o nome
Cap03_Ex07 e acione o botão OK. Lembre-se de manter selecionada do lado esquerdo a opção
Templates/Visual C#/Windows.
Observe o trecho marcado em negrito a seguir e coloque esse trecho de código na mesma
posição na parte do código gerada automaticamente pelo ambiente Visual Studio.
using System;
using System.Linq;
using System.Text;
{
class Program
{
static void Main(string[] args)
{
int NUMERO;
Console.Clear();
Console.Write("Entre um valor: ");
NUMERO = Convert.ToInt32(Console.ReadLine());
Console.WriteLine();
if (NUMERO >= 20 && NUMERO <= 90)
{
Console.WriteLine("O valor esta entre 20 e 90");
}
else
{
Console.WriteLine("O valor nao esta entre 20 e 90");
}
Console.Write("Tecle algo para encerrar... ");
Console.ReadKey();
}
}
}
3.5.2 Operador lógico de disjunção

O operador lógico de disjunção inclusiva || é utilizado quando pelo menos um dos relaciona-
mentos lógicos de uma condição é verdadeiro. Veja a Tabela 3.5.
Tabela 3.5 - Tabela verdade para o operador lógico de disjunção inclusiva

Condição 1 Condição 2 Resultado
Falsa Falsa Falso
Verdadeira Falsa Verdadeiro
Falsa Verdadeira Verdadeiro
Verdadeira Verdadeira Verdadeiro
O operador || faz com que uma operação seja executada se pelo menos uma das condições
mencionadas gerar um resultado lógico verdadeiro.

Elabore um programa que efetue a leitura de um valor numérico inteiro referente aos códigos
1, 2 ou 3 e apresente o valor do código por extenso. Qualquer outro valor deve apresentar a
mensagem Código inválido. Execute o comando FILE/New Project, selecione na caixa de diá-
logo New Project a opção Console Application, informe no campo Name o nome Cap03_Ex08
e acione o botão OK. Lembre-se de manter selecionada do lado esquerdo a opção Templates/
Visual C#/Windows.
using System;
using System.Linq;
using System.Text;
{
class Program
{
{
int CODIGO;
Console.Clear();
Console.Write("Entre o codigo de acesso: ");
CODIGO = Convert.ToInt32(Console.ReadLine());
if (CODIGO == 1 || CODIGO == 2 || CODIGO == 3)
{
switch (CODIGO)
{
case 1: Console.WriteLine("um"); break;
case 2: Console.WriteLine("dois"); break;
case 3: Console.WriteLine("tres"); break;
}
}
else
{
Console.WriteLine("Codigo invalido");
}
Console.ReadKey();
}
}
}
3.5.3 Operador Lógico de Negação

O operador lógico de negação ! é utilizado quando é necessário estabelecer que uma condição
deve ser não verdadeira ou não falsa. O operador ! inverte o estado lógico de uma condição. Veja a
Tabela 3.6.
Tabela 3.6 - Tabela verdade para o operador lógico de negação
Condição Resultado
Verdadeira Falso
Falso Verdadeira
O operador ! executa determinada operação, invertendo o resultado lógico da condição.
Elabore um programa que efetue a leitura de um valor numérico inteiro e apresente o resulta-
do caso este não seja maior ou igual a 3. Execute o comando FILE/New Project, selecione na
caixa de diálogo New Project a opção Console Application, informe no campo Name o nome
using System;
using System.Linq;
using System.Text;
{

class Program
{
{
float A, B, C, X;
Console.Clear();
Console.Write("Entre o valor <A>: ");
A = Convert.ToSingle(Console.ReadLine());
Console.Write("Entre o valor <B>: ");
B = Convert.ToSingle(Console.ReadLine());
Console.Write("Entre o valor <C>: ");
C = Convert.ToSingle(Console.ReadLine());
if (!(C > 5))
{
X = (A + B) * C;
}
else
{
X = (A - B) * C;
}
Console.WriteLine("Resultado de X = " + X.ToString());

Console.ReadKey();
}
}
}
3.6 Divisibilidade
Divisibilidade é a qualidade do que é divisível. Nesse contexto, dois conceitos devem ser
conhecidos e entendidos por nós, programadores de computador: múltiplos e divisores de números
naturais. Entende-se por número natural um valor numérico que seja inteiro e positivo.
Múltiplos são os resultados obtidos da multiplicação de dois números naturais, enquanto diviso-
res são números que dividem outros números com o objetivo de gerar um resultado exato de divisão,
ou seja, obter resto de divisão sempre zero. Quando o resto de uma divisão de números naturais é igual
a zero, tem-se divisibilidade, ou seja, resultado de divisão exata.
A linguagem C# possui como operador aritmético para auxiliar o cálculo de divisibilidade o
símbolo % (porcentagem). Usamos esse operador aritmético quando necessitamos calcular o valor
do resto de uma divisão de valores inteiros.
A operação de divisibilidade usada na linguagem C# a partir do operador aritmético % é baseada em uma fórmula mate-
mática documentada pelo professor Knuth em seu livro “The Art of Computer Programming” como sendo:
a
r = a -n
n
A incógnita r representa o resto da divisão, a incógnita a representa o dividendo e a incógnita n o divisor. O símbolo que
circunda a divisão chama-se piso e significa considerar na divisão apenas a parte inteira do valor do quociente. Há tam-
bém o símbolo teto quando deve-se considerar a parte intyeira da divisão somada de mais uma unidade. Veja:
x Parte inteira superior

x Parte
arte inteira inferior
Para saber mais consulte o livro:
KNUTH, D. E.
The Art of Computer Programming: Fundamental Algorithms. vol 1
Editora Addison-Wesle
Ano de publicação: 1972.
O próximo exemplo também será mostrado com o uso do modo console de escrita de progra-
mas na linguagem C#.
Elabore um programa que leia um valor numérico inteiro e apresente esse valor caso seja
este divisível por 4 e 5. Não sendo divisível por 4 e 5, o programa deve apresentar a mensa-
gem “Valor não é divisível por 4 e 5”. Execute o comando FILE/New Project, selecione na cai-
xa de diálogo New Project a opção Console Application, informe no campo Name o nome
using System;
using System.Linq;
using System.Text;
{
class Program
{

{
int N, R4, R5;
Console.Clear();
Console.Write("Entre um valor numerico natural: ");
N = Convert.ToInt32(Console.ReadLine());
R4 = N % 4;
R5 = N % 5;
if (R4 == 0 && R5 == 0)
{
Console.WriteLine(N.ToString());
}
else
{
Console.WriteLine("Valor nao divisivel por 4 e 5.");
}
Console.ReadKey();
}
}
}
Vamos recapitular?
Neste capítulo foram apresentados os detalhes sobre: condição, decisão, operadores rela-
cionais, operadores lógicos, decisão simples, decisão composta, decisão seletiva e divisibilidade.
Agora é com você!
1) Ler três valores inteiros (variáveis A, B e C) e apresentá-los em ordem crescente.

2) Ler quatro valores reais referentes a quatro notas escolares de um aluno e apresentar
uma mensagem informando se o aluno foi aprovado ou reprovado. Para determinar
a aprovação do aluno, considere a média escolar maior ou igual a 5. Apresentar nas
mensagens o valor da média do aluno.
3) Ler dois valores numéricos inteiros e apresentar o resultado da diferença do maior
valor em relação ao menor valor.
4) Ler quatro valores inteiros e exibir somente aqueles que forem divisíveis por 2 e 3.
5) Ler um valor inteiro qualquer e apresentar uma mensagem informando se ele é par
ou ímpar.
4
Programação
com Laços
Para começar
Este capítulo apresenta detalhes sobre o uso de laços para repetição de trechos de programas. São
apresentadas as três formas populares de laço: condicional pré-teste, condicional pós-teste e incondicional.
4.1 Laços e detalhes operacionais

No estudo que estamos fazendo sobre programação de computadores, já vimos como proceder
com o uso de uma programação meramente sequencial e com o uso de tomada de decisões. Ainda
não tivemos a necessidade de ter que repetir mais de uma vez determinado trecho de programa, o
que será apresentado agora.
Sabemos que a capacidade operacional de um computador é executar programas e que os pro-
gramas (obtidos a partir de algoritmos) são sequências de instruções que dão certa ordem de execu-
ção a um computador. Por vezes algumas dessas ordens devem ser repetidas , e para fazer esse tipo
de ação temos a técnica de uso dos laços de repetição.
Os laços que podemos usar com as linguagens C e C++ são três: um laço de ação condicio-
nal pré-teste (com a condição de controle no início do laço), um laço de ação condicional pós-teste
(com a condição de controle no fim do laço) e um laço de ação incondicional operacionalizado por
uma variável de controle.
59
Os exemplos de que faremos uso neste capítulo são todos voltados ao modo gráfico. Atente
para a necessidade de selecionar a opção Windows Forms Application quando formos criar os proje-
tos a seguir.
Além do Zezinho do ITA de 1961 produzido como trabalho de graduação de Engenharia dos alunos José Ellis Ripper
Filho, Fernando Vieira de Souza, Alfred Wolkmer e Andras Vasarhey, também foi construído na USP em 1972 um compu-
tador brasileiro chamado Patinho Feio. Para saber mais, vá ao Google e pesquise por “computador zezinho” e “computa-
dor patinho feio”. Procure também por “computador cisne branco”.
Podemos usar os laços condicionais para a definição de laços interativos (com interferência
ativa do usuário do programa, que pode determinar o momento de parada do laço) e para laços itera-
tivos (em que o controle da execução do laço está condicionado à execução do programa e o usuário
não tem poder de interferência, pois o ciclo de ação do laço deve ser executado até sua conclusão).
4.2 Laço condicional pré-teste

Para a execução de laço condicional pré-teste temos na linguagem C# a instrução while, que
permite executar um conjunto de instruções enquanto a condição verificada permanecer válida. No
momento em que essa condição não for válida, o processamento da rotina será desviado para fora do
laço. A sintaxe dessa estrutura de laço corresponde a:
while (condição)
{
<executa instrução 1 enquanto condição for válida>;
<executa instrução N enquanto condição for válida>;
}
Exercício Resolvido
Elabore um programa que apresente o resultado da fatorial de um número qualquer inteiro
fornecido. Execute o comando FILE/New Project, forneça o nome Cap04_Ex01 para o pro-
Agora vamos criar o formulário para o programa. Estando com um novo projeto aberto, mude
a propriedade Text do formulário para Fatorial Pré-Teste Verdadeiro.
Em seguida, é inserido no formulário, no canto superior esquerdo, um controle Label, tendo
sua propriedade Text alterada para “Informe um valor:”. Ao lado desse Label, insira um con-
trole TextBox. Coloque um controle Button, o qual deve ter sua propriedade Text alterada com
o texto Processar. A Figura 4.1 mostra o formulário até o momento.
Figura 4.1 - Formulário com as propriedades e o botão.
A partir do ponto em que o formulário esteja concluído, é montado o código de programa que
efetua o cálculo e a apresentação do resultado da fatorial. Portanto, acione o botão Processar e
escreva o código a seguir marcado em negrito.

{
long FAT = 1;
int N, I;
N = Convert.ToInt32(textBox1.Text);
I = 1;
while (I <= N)
{
FAT = FAT * I;
I = I + 1;
}
MessageBox.Show
(
"Fatorial = " + FAT.ToString(),
"Resultado da Fatorial",
);
textBox1.Clear();
textBox1.Focus();
}
Programação com Laços 61

Observe que a variável FAT é iniciada com valor 1. A mesma abordagem poderia ter sido
usada para a variável I.
Após ser capturado o valor informado no controle TextBox para a variável N, é inicializada a
variável do contador, a qual é atribuída com o valor 1, no caso, (I = 1).
Em seguida, a instrução while (I <= N) efetua a verifi-
cação da condição estabelecida. Se a condição for verdadeira,
pois o valor da variável I, que nesse momento é 1, é realmente Programadores em linguagem C# cos-
tumam não utilizar como contador a for-
menor ou igual a N, e enquanto for, deve processar o laço.
ma I = I + 1, apresentada no exemplo
É iniciada a execução da rotina de instruções do laço anterior. Eles preferem as formas I +=
1 ou I++. A forma I++ é normalmen-
delimitado com a instrução while. Depois de ter proces- te usada quando a contagem é efetuada
sado o cálculo da fatorial, o programa apresenta o resul- de unidade em unidade (como foi abor-
tado logo após a conclusão da execução do laço. dado no Capítulo 3); a forma I += 1,
quando o passo de contagem tem algum
Durante a execução do laço, a linha de código FAT valor diferente de 1. Vale ressaltar, tam-
= FAT * I efetua o cálculo da fatorial, e a instrução I = I + 1 bém, que podem ser utilizados, além de
indica o acréscimo de 1 à variável contador. Observe que a +=, os operadores -=, *= e /= para
realizar outras operações de incremento
variável I começa com o valor 1, mas possui os valores 2, 3,
ou decremento de valores em determi-
4 e assim por diante até o limite definido na variável N. Por nada variável. Nos próximos exemplos, a
exemplo, se for fornecido o valor 5 para a variável N, ocorre a forma I = I + 1 não será mais utilizada.
multiplicação na variável FAT dos valores 1 * 2 * 3 * 4 * 5, que
resulta ao final em 120.
4.3 Laço condicional pós-teste

Para a execução de laço condicional pós-teste temos na linguagem C# a instrução do ... while,
que faz um teste lógico no final do laço, verificando se é possível executar novamente o trecho de
instruções subordinadas a ele. Esse laço tem como característica operacional sempre executar o
bloco subordinado ao laço no mínimo uma vez.
A estrutura de laço do ... while tem seu funcionamento controlado por condição, mas esse tipo de
laço, como dito, executa o bloco de instruções subordinadas ao laço pelo menos uma vez antes de verifi-
car a validade da condição estabelecida, diferentemente do laço pré-teste while, que executa somente um
conjunto de instruções quando a condição for favorável.
Dessa forma, do ... while funciona em sentido contrário ao while, pois sempre processa um
conjunto de instruções no mínimo uma vez, mesmo que a condição não seja válida. A instrução
do ... while pode ser escrita com a sintaxe:
do
{
<faz a execução da instrução 1 enquanto condição válida>;
<faz a execução da instrução N enquanto condição válida>;
}
while (condição);
a propriedade Text do formulário para Fatorial Pós-Teste Verdadeiro.
Em seguida, é inserido no formulário, no canto superior esquerdo, um controle Label, tendo
{
long FAT = 1;
int N, I;
I = 1;
do
{
FAT *= I;
I++;
}
while (I <= N);

MessageBox.Show
(
);
textBox1.Clear();
textBox1.Focus();
}
Assim que o programa for executado, a variável contador será inicializada com o valor 1 (I =
1). Em seguida, a instrução do indica que todo trecho de instruções situado até a instrução while
(I <= N) será executado enquanto a variável I for menor ou igual ao valor da variável N.
4.4 Laço incondicional

Já vimos os conceitos de laços com while e do ... while. Nessas duas técnicas, vimos que é pos-
sível elaborar trechos que executem uma parte do programa um determinado número de vezes com
a utilização de uma variável contador. Além das formas que já vimos, há outra forma de facilitar o
uso de contadores por meio do laço for, que possui a sintaxe:
for (<início>; <fim>; <incremento>)

{
<executa instrução 1>
<executa instrução N>
}
a propriedade Text do formulário para Fatorial Incondicional.
Em seguida, é inserido no formulário um controle Label, no canto superior esquerdo, tendo
{
long FAT = 1;
int N, I;
for (I = 1; I <= N; I++)
{
FAT *= I;
}
MessageBox.Show
(
);
textBox1.Clear();
textBox1.Focus();
}
O laço for nas linguagens de programação C e C++ é executado por uma instrução que recebe
três parâmetros de trabalho, separados por ponto e vírgula. O primeiro parâmetro é representado
por uma variável e seu valor inicial; o segundo parâmetro, pela condição de finalização da execução
do laço; o terceiro e último parâmetro, pelo contador de incremento que ocorre entre os valores ini-
cial e final da contagem.

4.5 Controles em tempo de execução
Nos exemplos apresentados no nosso estudo, fizemos uso de alguns controles na criação de
formulário para estabelecermos a interface gráfica de nossos programas. Todos os controles que
usamos foram selecionados na ferramenta Toolbox e inseridos no formulário. Em algumas ocasiões
fizemos a alteração de alguma propriedade para ajustar a certa necessidade.
O uso de controles em um formulário pode ser definido manualmente, como fizemos até este
momento, ou automaticamente, quando eles podem ser criados em tempo de execução, ou seja, o próprio
programa que estamos escrevendo pode criar e colocar em uso qualquer controle existente na Toolbox.
Veremos neste capítulo um uso bem simples dessa ação. Mas teremos uma base inicial para
fazer uso desse recurso em outras ocasiões.
No sentido de demonstrar de forma simplificada a criação de controle do tipo Label em tempo
de execução, considere um programa que apresenta a mensagem Estudo de Programação na
tela de um formulário. Execute o comando FILE/New Project, forneça o nome Cap04_Ex04
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.
A partir desse momento, no formulário Form1, acione-o com um duplo clique do mouse e perce-
ba que a tela do editor de código é então apresentada. Insira, nesse instante, o código de programa
seguinte entre as chaves da instrução private void Form1_Load(object sender, EventArgs e).
private void Form1_Load(object sender, EventArgs e)
{
Label ROTULO = new Label();
ROTULO.Text = "Estudo de Programação";
ROTULO.SetBounds(80, 115, 153, 25);
this.Controls.Add(ROTULO);
}
No código anterior estamos definindo um objeto (algo semelhante à definição de uma variá-
vel) identificado com o nome ROTULO, instanciado a partir da classe Label (semelhante a
informar o tipo de uma variável), que será usado para a apresentação da mensagem “Estudo
de Programação”. Aqui estamos dizendo que queremos usar no formulário um controle Label.
Na segunda linha, estamos alterando o conteúdo da propriedade Text do objeto ROTULO com
a mensagem a ser apresentada.
A terceira linha mostra que a propriedade SetBounds(80, 115, 153, 25) está sendo configurada
com os valores 80, 115, 153 e 25, que são, respectivamente, as informações da posição de colu-
na (80), posição de linha (115), tamanho do controle (153) e largura do controle (25).
A quarta linha do código faz a apresentação do con-
trole na tela do formulário. Esse efeito de apresenta-
ção ocorre por conta do uso da linha de código this.
Controls.Add(ROTULO);, em que o controle Label
está sendo adicionado pelo método Controls.Add()
ao formulário Form1 representado pela cláusu-
la this, que significa o próprio objeto, nesse caso,
ROTULO. No lugar da cláusula this, não pode ser
usado o objeto ROTULO pelo fato de ser passado
como parâmetro do método Add(). Essa é uma for-
ma de fazer referência indireta a um objeto, quando
ele está em uso e não pode ser referenciado explici-
Figura 4.4 - Formulário com controle
tamente. A Figura 4.4 mostra o resultado da apre- Label gerado em tempo de execução.
sentação de um controle em tempo de execução.
Para demonstrar de forma simplificada a criação de controle do tipo Button em tempo de exe-
cução, considere um pequeno programa que apresenta um botão com a identificação Me Acione
na tela de um formulário. Após o botão ser acionado, o programa deve apresentar a mensagem:
“Uau!!! Você me acionou.”, com o nome do usuário como título da barra de título da caixa de
mensagem. Execute o comando FILE/New Project, forneça o nome Cap04_Ex05 para o projeto
e acione o botão OK. Lembre-se de manter selecionada do lado esquerdo a sequência de opções
A partir desse momento, no formulário Form1 acione com um duplo clique do mouse a área
interna do formulário e perceba que a tela do editor de código é então apresentada. Insira,
nesse instante, o código de programa seguinte em negrito entre as chaves da instrução private
void Form1_Load(object sender, EventArgs e).

{
Button BOTAO = new Button();
BOTAO.Text = "Me Acione";
BOTAO.SetBounds(84, 100, 120, 46);
BOTAO.Click += new System.EventHandler(Apresenta);
this.Controls.Add(BOTAO);
}

Observe no código anterior a definição do objeto BOTAO, instanciado a partir da classe Button.
As demais linhas de código já são conhecidas e idênticas às linhas do programa anterior
comentado.
Atente para a linha de código com a instrução de acionamento do botão no formulário
BOTAO.Click += new System.EventHandler(Apresenta);, à qual adiciona o evento (Event
Handler) de acionamento do botão por meio de um clique do ponteiro do mouse (BOTAO.
Click), que executa a chamada do método identificado como Apresenta.
O código do método Apresenta deve ser escrito logo abaixo do código anterior. Isso posto,
escreva as próximas linhas de código logo abaixo da definição do bloco da instrução private
void Form1_Load(object sender, EventArgs e). Observe o trecho a seguir.
private void Apresenta(object sender, EventArgs e)

{
MessageBox.Show("Uau!!! Você me acionou.");
}
Observe nesse código o uso da classe MessageBox com o método Show com a string a ser
escrita como mensagem. Os parâmetros identificados como “object sende” e “EvenrArrgs e”
são utilizados para receber os valores de tratamento da ação de acionamento do botão de dis-
paro desse método. Nesse caso, o botão Me Acione.
As Figuras 4.5 e 4.6 apresentam, respectivamente, as imagens do formulário com o botão e o
resultado na caixa de mensagem.
Figura 4.5 - Formulário com controle Figura 4.6 - Caixa

Button, gerado em tempo de execução. de mensagem.
No sentido de dar uma ideia do código completo do programa anterior, observe na estrutura
sintática do programa os pontos marcados em negrito, que foram as partes inseridas por nós.
using System;
using System.Data;
using System.Linq;
using System.Text;
{
{
public Form1()
{
}
{
Button BOTAO = new Button();
BOTAO.Text = "Me Acione";
BOTAO.SetBounds(84, 100, 120, 46);
BOTAO.Click += new System.EventHandler(Apresenta);
this.Controls.Add(BOTAO);
}
private void Apresenta(object sender, EventArgs e)

{
MessageBox.Show("Uau!!! Você me acionou.");
}
}
}
Agora que temos uma visão de como criar controle em tempo de execução, fica mais fácil escrever
um programa um pouco mais complexo, e teremos a oportunidade de usar a instrução de laço foreach
(para cada) que percorre do início até o final todos os elementos que compõem uma estrutura.
Elabore um programa que efetue a leitura de oito notas escolares de uma sala de aula com oito
alunos e apresente o resultado da média da sala. Execute o comando FILE/New Project, forne-
ça o nome Cap04_Ex06 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.
O código apresentado fará a criação dos controles necessários ao programa em tempo de execu-
ção. A Figura 4.7 mostra o visual que o formulário terá.

Figura 4.7 - Formulário com controles criados em tempo de execução.
A partir desse momento, no formulário Form1 acione com um duplo clique do mouse a área
interna do formulário e perceba que a tela do editor de código é então apresentada. Insira,
nesse instante, o código de programa seguinte em negrito entre as chaves da instrução private
void Form1_Load(object sender, EventArgs e).
Label ROTULO1 = new Label();
Button BOTAO1 = new Button();
int I, POSICAO;
this.Text = "Média Escolar - Variável Indexada";

this.Width = 329;
this.Height = 300;
ROTULO1.Text = "Entre com as oito médias escolares:";

ROTULO1.SetBounds(12, 19, 176, 13);
this.Controls.Add(ROTULO1);
ROTULO2.Text = "Média Geral:";

ROTULO3.Name = "Label3";
ROTULO3.Text = "Label3";
POSICAO = 45;
for (I = 1; I <= 8; ++I)
{
TextBox CAMPO = new TextBox();
CAMPO.Name = "TextBox" + I.ToString();
CAMPO.SetBounds(15, POSICAO, 60, 20);
this.Controls.Add(CAMPO);
POSICAO += 26;
}
BOTAO1.Text = "Processar";
BOTAO1.SetBounds(133, 198, 73, 23);
BOTAO1.Click += new System.EventHandler(Processar);
this.Controls.Add(BOTAO1);
BOTAO2.Text = "Limpar";
BOTAO2.Click += new System.EventHandler(Limpar);
Após definição do código que fará a criação dos componentes, é necessário definir os códigos
a serem executados com o acionamento dos botões Limpar e Processar.
Abaixo da chave de fechamento da função private void Form1_Load(object sender, EventArgs e),
forneça os códigos a seguir:
private void Processar(object sender, EventArgs e)

{
float SOMA, MEDIA, VALOR;
int J;
SOMA = 0;
J = 0;
foreach (Control CONTROLE in this.Controls)
{
if (CONTROLE is TextBox)
{
VALOR = Convert.ToSingle(((TextBox)CONTROLE).Text);
SOMA += VALOR;
J += 1;
}
MEDIA = SOMA / 8;
this.Controls["Label3"].Text = MEDIA.ToString();
}
}
private void Limpar(object sender, EventArgs e)

{
{
{
((TextBox)CONTROLE).Text = "";
}
this.Controls["Label3"].Text = "Label3";
this.Controls["TextBox1"].Focus();
}
}

A seguir, são apresentadas as explicações do funcionamento de cada parte mais importante do
programa anterior, iniciando pelo bloco de definição das variáveis e objetos utilizados no trecho de
código de manipulação do formulário, em que:

int I, POSICAO;
Observe que há no trecho de código objetos definidos (instanciados) como do tipo Label e
Button. Note que objetos são precedidos da cláusula new, sendo essa uma das formas pela qual con-
seguimos diferenciar variáveis de objetos. Por exemplo, I e POS são variáveis, possuem apenas à
esquerda a definição do tipo de dado associado e ao lado direito não há o uso de new.

this.Width = 329;
this.Height = 300;
O trecho anterior efetua a configuração de algumas propriedades da janela do formulário,

como o nome da barra de títulos (Title), a largura da janela (Width) e a altura (Height) da janela.


Os três trechos de definição dos rótulos são idênticos. Cabe observar que o terceiro trecho de
código, quando da definição da propriedade Name em ROTULO3.Name, determina a esse controle o
nome Label3, que seria o nome especificado ao controle se ele fosse inserido manualmente no formulário.
POSICAO = 45;
for (I = 1; I <= 8; ++I)
{
POSICAO += 26;
}
O trecho anterior é responsável por apresentar os oito controles do tipo TextBox. Note a ins-
trução TextBox CAMPO = new TextBox(), em que cada uma das posições da matriz é instanciada
separadamente. Outro detalhe é o uso da instrução POSICAO += 26, que define a posição de apre-
sentação do controle no formulário junto à instrução CAMPO.SetBounds(15, POSICAO, 60, 20).
Atente para a instrução CAMPO.Name = “TextBox” + I.ToString(), em que se definem o nome de
cada um dos controles TextBox mais o seu número de identificação por meio de I.ToString(), em que
o valor da variável I é convertido para seu formato string, os quais serão apresentados no formulário.
A parte do código que configura as propriedades dos botões Processar e Limpar possui deta-
lhes e características já conhecidos, dispensando maiores comentários.

{
int J;
SOMA = 0;
J = 0;
{
{
SOMA += VALOR;
J += 1;
}
MEDIA = SOMA / 8;
}
}
No código do botão Processar, há alguns detalhes conhecidos, exceto a instrução this.

Controls[“Label3”].Text = MEDIA.ToString(), que faz acesso ao controle Label3 existente no for-
mulário, aqui representado pelo trecho da instrução this.Controls e a instrução foreach que nesse
contexto (poderá ser usada para outras operações, como será visto no próximo capítulo) faz uma
varredura (iteração) no formulário, localizando um a um os componentes existentes e associando-
-os ao objeto CONTROLE. A cada iteração realizada por foreach a instrução seguinte a ela: if
(CONTROLE is TextBox) verifica se CONTROLE possui um controle TextBox e se essa condição
for verdadeira pega o conteúdo do controle e atribui este à variável VALOR. Em seguida efetua o
somatório desses valores, atribuindo o conteúdo da variável VALOR na variável SOMA.

{
{

{
}
}
}
No código do botão Limpar, há muitos detalhes conhecidos, exceto a instrução this.

Controls[“TextBox1”].Focus(), usada para devolver o foco de acesso ao controle do primeiro campo
de entrada do formulário.
No sentido de dar uma ideia ampla do código completo de programa, observe sua estrutura
sintática.
using System;
using System.Data;
using System.Linq;
using System.Text;
{
{
public Form1()
{
}

{
int I, POSICAO;

this.Width = 329;
this.Height = 300;


POSICAO = 45;
for (I = 1; I <= 8; ++I)
{
POSICAO += 26;
}
}

{
int J;
SOMA = 0;
J = 0;
{
{
SOMA += VALOR;
J += 1;
}
MEDIA = SOMA / 8;
}

}

{
{
{
}
}
}
}
}
Vamos recapitular?
Neste capítulo foram apresentados detalhes sobre o uso dos laços para a repetição de trechos de
programas. Foram vistos laços: condicional pré-teste, condicional pós-teste e incondicional.
Agora é com você!
1) Desenvolver a codificação dos seguintes problemas a serem transformados em pro-

gramas de computador. Utilize o laço while.
a) Apresentar todos os valores numéricos inteiros ímpares situados na faixa de 0 a
20.
b) Apresentar o total da soma dos cem primeiros números inteiros, representados
pela sequência 1+2+3+4+5+6+7+...+97+98+99+100.
c) Apresentar todos os números divisíveis por 4 que sejam menores que 30. Iniciar
a contagem com o valor 1 (um).
d) Apresentar os quadrados dos números inteiros de 15 a 200.
e) Apresentar o resultado da soma de todos os valores pares existentes na faixa
numérica de 1 a 50.
2) Desenvolver a codificação dos problemas apresentados no exercício 1 com o laço
do...while.
3) Desenvolver a codificação dos problemas apresentados no exercício 1 com o laço for.
5
Programação
com Matrizes
Para começar
Este capítulo apresenta as técnicas básicas de uso de arranjos de valores, também conhecidos como
matrizes. Nesta parte do estudo é apresentado o uso de matrizes de uma dimensão e duas dimensões, tanto
em modo estático como em modo dinâmico. São apresentadas as técnicas de ordenação e pesquisa por
meio de métodos C#.
5.1 Matriz de uma dimensão

Uma matriz de uma dimensão é um tipo de estrutura de dados que armazena uma coleção de
dados. Esse tipo de estrutura é conhecido como vetor, arranjo, variável composta, variável indexada,
entre outras formas. É usado comumente na criação de tabelas simples. A matriz usa uma única variá-
vel, que tem determinado tamanho e pode armazenar mais de um valor (conhecido como elemento).
O tamanho de uma matriz é conhecido como dimensão, constituída por constantes inteiras e positivas.
Os nomes dados às matrizes seguem as mesmas regras de nomes atribuídos a variáveis simples.
A matriz de uma dimensão é representada por nome, tamanho (dimensão) entre colchetes e
tipo, tendo a seguinte sintaxe:
tipo[] nome = new tipo[dimensão];
77
em que:
» <tipo> - o tipo de dado que será
armazenado;
Todos os programas escritos até este momento,
» <nome> - o nome atribuído à ma- exceto os programas com uso de operadores lógicos
triz (arranjo); do Capítulo 4, foram escritos usando interface gráfi-
ca. Neste capítulo será usado o modo console (modo
» <dimensão> - o tamanho em número texto), pois o ponto central deste estudo será o uso
de elementos a serem ar- das técnicas de manipulação de variáveis inde-
mazenados. xadas e como elas funcionam. Nessa etapa, usar
a parte gráfica aumentará em muito o código dos
Uma variável pode conter apenas um valor por programas por ser necessária a inserção de vários
vez. No caso de uma matriz, ela pode armazenar mais de controles TextBox em tempo de execução, como já
um valor por vez, pois é dimensionada exatamente para apresentado no final do capítulo anterior. Fazer a
inserção manual desses controles é uma ação que
essa finalidade. Vale ressaltar que a manipulação dos ele- não compensará nessa etapa de estudo. Dessa for-
mentos de uma matriz ocorre de forma individualizada, ma, no momento da criação de cada um dos pro-
pois não é possível usar todos os elementos do conjunto jetos de trabalho deste capítulo use após executar
ao mesmo tempo. FILE/New Project a opção Console Application.
Elabore um programa que efetue o cálculo e apresente a média geral das médias individuais de
uma turma de oito alunos. A média a ser obtida deve ser a média geral de cada aluno obtida
durante o ano letivo. Execute o comando FILE/New Project, forneça o nome Cap05_Ex01 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.
As instruções deste programa devem ser escritas no bloco dentro da função Main(). Observe
em seguida o trecho de código em negrito.
using System;
using System.Linq;
using System.Text;
{
class Program
{
{
float[] MDG = new float[8];

float SOMA = 0, MEDIA;
int I;
Console.Clear();
for (I = 0; I <= 7; I++)
{
Console.Write("Media media {0}o. aluno: ", I + 1);
MDG[I] = Convert.ToSingle(Console.ReadLine());
SOMA += MDG[I];
}
MEDIA = SOMA / 8;
Console.WriteLine("Media Geral = {0:0.00}", MEDIA);
Console.ReadKey();
}
}
}
Observe que a instrução float[] MDG = new float[8]; define uma dimensão de oito posições
para a variável MDG, fazendo dessa variável um objeto instanciado a partir do tipo float.
A instrução Console.Write("Media media {0}o. aluno: ", I + 1); apresenta a mensagem de
entrada. O uso do artifício I + 1 faz a apresentação simulada de valores ordinais para a entrada das
médias. Dessa maneira, o valor da variável I, que possui a posição real do arranjo, é somado ao valor 1,
apresentando a informação em formato ordinal na mensagem de entrada. Quando o valor do índice
for 0, será dada a entrada da primeira nota; quando for 1, será a entrada da segunda nota e assim por
diante. O valor 0 (zero) entre chaves dentro do string da mensagem define o local no texto que um
valor numérico será apresentado. Na mensagem “Media Geral = {0:0.00}” define o local de apresen-
tação e a formatação do valor numérico (0.00).
Elabore um programa que receba o fornecimento de cinco valores inteiros em uma matriz
de uma dimensão (tipo vetor) e construa a matriz B de mesmo tipo e dimensão conforme a
seguinte lei de formação. Os elementos da matriz A que forem pares deverão ser multiplicados
por 5; se os elementos forem ímpares, deverão ser somados com 5. Ao final apresente as duas
matrizes. Execute o comando FILE/New Project, forneça o nome Cap05_Ex02 para o projeto e
acione o botão OK. Lembre-se de manter selecionada do lado esquerdo a sequência de opções
Programação com Matrizes 79

using System;
using System.Linq;
using System.Text;
{
class Program
{
{
int[] A = new int[10];

int[] B = new int[10];
int I;
// Entrada de dados
Console.Clear();
for (I = 0; I <= 9; I++)
{
Console.Write("Entre o {0,2}o. elemento: ", I + 1);
A[I] = Convert.ToInt32(Console.ReadLine());
}
// Processamento par ou impar
for (I = 0; I <= 9; I++)

if (I % 2 == 0)
B[I] = A[I] * 5;
else
B[I] = A[I] + 5;
// Apresentacao dos arranjos

for (I = 0; I <= 9; I++)
{
Console.Write("A[{0}] = {1,4} / ", I, A[I]);
Console.Write("B[{0}] = {1,4}", I, B[I]);
}
Console.ReadKey();
}
}
}
São utilizados no programa três laços de repetição do tipo for. O primeiro laço controla a
entrada dos dados no arranjo A, o segundo verifica se cada índice do arranjo A é par ou ímpar e faz
as devidas operações, atribuindo ao arranjo B os elementos calculados; o terceiro laço é utilizado
para apresentar ambos os arranjos.
No laço de repetição destinado ao processamento, é utilizada a instrução if (I % 2 == 0), sen-
do % um operador aritmético da linguagem Java que possibilita extrair o valor do resto de uma divi-
são sempre de números inteiros (o operador % não pode ser usado com valores do tipo real - float e
double). Essa operação recebe o nome de módulo. Qualquer valor de dividendo dividido por 2 que
tiver um resto igual a zero tem como dividendo um número par. Se o resto da divisão for 1, o divi-
dendo é um valor ímpar.
O código de formatação {0,2} é usado para determinar a apresentação de valores numéricos tabu-
lados da direita para a esquerda com duas casas, uma das quais é uma unidade e a outra, uma dezena.
5.2 Matriz de duas dimensões

Além da forma que temos de organizar os dados em uma lista de valores como a que usamos no
tópico anterior, podemos organizar os dados na forma de tabelas com matrizes de duas dimensões.
Em matrizes com mais de uma dimensão, os elementos também são manipulados individual-
mente, com a referência feita sempre por meio de dois índices: o primeiro para controlarmos a linha;
o segundo, para controlarmos a coluna. Dessa forma, TABELA[3][4] indica uma referência ao ele-
mento armazenado na linha 3 (quarta linha) e na coluna 4 (quinta coluna).
Uma matriz de duas dimensões sempre faz menção a linhas e colunas e será representada por
seu nome e tamanho máximo (dimensão) entre colchetes. Dessa forma, seria uma matriz de duas
dimensões TABELA[8][5], cujo nome é TABELA, com um tamanho de oito linhas (de 0 a 7) e cinco
colunas (de 0 a 4). Temos então uma matriz de 8 por 5 (8 x 5). Isso significa que em TABELA podem
ser armazenados até 40 elementos.
Uma matriz de duas dimensões é semelhante à de uma dimensão, e representada por nome,
tamanho (dimensão de linhas e colunas) entre colchetes e tipo, com a seguinte sintaxe:
tipo[,] nome = new tipo[linhas, colunas];

em que:
» <tipo> - o tipo de dado;
» <nome> - o nome atribuído ao arranjo;
» <linhas> - o tamanho de linhas para o arranjo;
» <colunas> - o tamanho de colunas para o arranjo.
Elabore um programa que efetue a leitura de nove valores inteiros dispostos em uma matriz
A de duas dimensões com três linhas e três colunas. Em seguida, o programa apresenta os
elementos existentes na diagonal principal. Execute o comando FILE/New Project, forneça o
As instruções deste programa devem ser escritas no bloco dentro da função Main(). Observe o
trecho de código em negrito a seguir.
using System;
using System.Linq;
using System.Text;
{
class Program
{
{
int[,] A = new int[3, 3];
int I, J, LIN = 7, COL = 0;
Console.Clear();
Console.SetCursorPosition( 0, 0);
Console.Write("Entre um valor na coordenada:");
Console.Write("Linha ...: ");
Console.Write("Coluna ..: ");
for (I = 0; I <= 2; I++)

{
for (J = 0; J <= 2; J++)
{
Console.SetCursorPosition(11, 2);
Console.Write("{0}", I + 1);
Console.Write("{0}", J + 1);
Console.Write("--> ");
A[I, J] = Convert.ToInt32(Console.ReadLine());
Console.Write(" ");
Console.SetCursorPosition(COL, LIN);
Console.Write("{0,4}", A[I, J]);
COL += 6;
}
LIN += 2;
COL -= 18;
}
Console.SetCursorPosition( 0,13);
Console.Write("Saida - Diagonal Principal");
Console.SetCursorPosition( 0,15);
for (I = 0; I <= 2; I++)

{
for (J = 0; J <= 2; J++)
{
if (I == J)
{
Console.Write("A[{0},{1}]", I + 1, J + 1);
Console.WriteLine(" = {0,4}", A[I,J]);
}
}
}
Console.ReadKey();
}
}
}
O programa anterior usa um arranjo de duas dimensões, e para sua execução foram neces-
sários dois laços para controlar o acesso às posições de índice.
Um detalhe novo no programa é o método SetCursorPosition() que faz o posicionamento do
cursor na tela de execução do programa. Para uso desse método, é necessário passar dois parâmetros,

o primeiro referente à coordenada da coluna e o segundo referente à coordenada da linha. Note que
os valores desses parâmetros se iniciam em zero.
O primeiro computador instalado no Brasil foi um UNIVAC-102, comprado pelo governo do estado de São Paulo em
1957 para ser usado para calcular o consumo de água na capital. Para saber mais, sobre consulte em http://www.din.
uem.br/museu/hist_nobrasil.htm (fev/2014).
5.3 Matriz dinâmica

As matrizes estáticas usadas nos tópicos anteriores possuem a desvantagem de serem limitadas
e de ocuparem um espaço de memória quando não estão completas. Uma matriz dinâmica se carac-
teriza por ser uma estrutura de dados cujo tamanho se encontra indefinido. O tamanho da matriz
será definido em tempo de execução do programa a partir da interação do usuário com o programa.
Uma matriz dinâmica, para ser utilizada na linguagem C#, exige que usemos uma estrutura
de lista genérica a partir da classe List e que façamos a inserção de elementos com o método Add(),
sendo representada pelo tipo lista genérica, tipo de dado, por nome, e com a seguinte sintaxe:
List<tipo> nome = new List<tipo>();
em que:
» <tipo> - o tipo de dado que será armazenado;
» <nome> - o nome atribuído à matriz (arranjo).
Elabore um programa que crie uma matriz de uma dimensão dinâmica para armazenar diversos
valores reais. Não se sabe quantos valores o usuário do programa desejará fornecer. O progra-
ma deverá solicitar a quantidade de valores a ser fornecida e após a recepção dos valores fazer a
apresentação destes. Execute o comando FILE/New Project, forneça o nome Cap05_Ex04 para o
projeto e acione o botão OK. Lembre-se de manter selecionada do lado esquerdo a sequência de
using System;
using System.Linq;
using System.Text;
{
class Program
{
{
int I, TAMANHO;
float ENTRADA;
List<float> MATRIZ = new List<float>();
// Entrada de dados
Console.Clear();
Console.Write("Quantos elementos: ");
TAMANHO = Convert.ToInt32(Console.ReadLine());
for (I = 1; I <= TAMANHO; I++)
{
Console.Write("Entre o {0,3}o. elemento: ", I);
ENTRADA = Convert.ToSingle(Console.ReadLine());
MATRIZ.Add(ENTRADA);
}
// Saída de dados
for (I = 0; I < MATRIZ.Count; I++)
{
Console.Write("{0,3}o. elemento: ", I + 1);
Console.WriteLine("{0:0.00}", MATRIZ[I]);
}
Console.ReadKey();
}
}
}
Ao executar o programa, não insira valores de quantidade muito altos por dois motivos: pri-
meiro, pelo fato de precisar informar o número de valores solicitado; segundo, por utilizar o tipo

int para a variável TAMANHO e a quantidade fornecida não deve ultrapassar o tamanho desse
tipo de dado.
Veja que no laço de entrada estamos usando o método Add() para efetuar a entrada de cada
elemento na variável MATRIZ. Note que a função Add() opera em sentido ordinal, daí o laço que
controla a entrada estar definido como for (I = 1; I <= TAMANHO; I++).
O laço de saída é controlado pelo laço for (I = 0; I < MATRIZ.Count; I++), em que a proprie-
dade Count informa para o laço a quantidade de elementos que estão inseridos na variável MATRIZ.
5.4 Ordenação e pesquisa

As atividades de ordenação e pesquisa de elementos em matrizes são uma das atividades mais
requisitadas no trabalho de programação. Sabemos, a partir do estudo de lógica de programação,
que existem algumas técnicas para realizarmos esse tipo de trabalho. No entanto, a linguagem C#
possui métodos internos que efetuam facilmente essas operações sem que precisemos nos preocupar
com suas questões lógicas.
Elabore um programa entre dez valores inteiros e os apresente em ordem crescente. Execute o
Basic/Windows.
using System;
using System.Linq;
using System.Text;
{
class Program
{
{
int[] A = new int[10];

int I;
// Entrada de dados
Console.Clear();
for (I = 0; I <= 9; I++)
{
Console.Write("Entre o {0,2}o. elemento: ", I + 1);
A[I] = Convert.ToInt32(Console.ReadLine());
}
// Ordenação
Array.Sort<int>(A);
// Apresentação ordenada
for (I = 0; I <= 9; I++)

{
Console.WriteLine("A[{0}] = {1,4}", I, A[I]);
}
Console.ReadKey();
}
}
}
Veja que a operação de ordenação é executada pela instrução Array.Sort<int>(A), em que o

método Array.Sort do tipo int (tipo de dado da matriz) efetua a ordenação crescente na variável
indicada, nesse caso A. Caso queira efetuar uma ordenação decrescente, basta colocar imediata-
mente após a instrução Array.Sort<int>(A) a instrução Array.Reverse(A).
Elabore um programa entre dez nomes de pessoas e os apresente em ordem decrescente. Execu-
te o comando FILE/New Project, forneça o nome Cap05_Ex06 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.

using System;
using System.Linq;
using System.Text;
{
class Program
{
{
string[] A = new string[10];

int I;
// Entrada de dados
Console.Clear();
for (I = 0; I <= 9; I++)
{
Console.Write("Entre o {0,2}o. nome: ", I + 1);
A[I] = Console.ReadLine();
}
// Ordenação
Array.Sort<string>(A);
Array.Reverse(A);
// Apresentação ordenada
for (I = 0; I <= 9; I++)

{
Console.WriteLine("{0,2}o. nome = {1}", I + 1, A[I]);
}
Console.ReadKey();
}
}
}
A pesquisa de elementos de uma matriz pode ser facilmente executada com método específico
a essa ação. O próximo exemplo demonstra essa possibilidade.
Elabore um programa entre cinco nomes de pessoas e em seguida solicite um nome para pes-
quisa. Se o nome existir, deve ser apresentado, caso contrário o programa deve apresentar men-
sagem informando que o elemento não foi localizado. Execute o comando FILE/New Project,
forneça o nome Cap05_Ex07 para o projeto e acione o botão OK. Lembre-se de manter selecio-
nada do lado esquerdo a sequência de opções Templates/Visual Basic/Windows.
using System;
using System.Linq;
using System.Text;
{
class Program
{
{
string[] A = new string[5];

int I;
string PESQ;
// Entrada de dados
Console.Clear();
for (I = 0; I <= 4; I++)
{
A[I] = Console.ReadLine();
}
// Pesquisa

Console.Write("Entre nome a pesquisar: ");
PESQ = Console.ReadLine();
I = Array.IndexOf(A, PESQ);
if (I >= 0)
{
Console.Write("{0} foi localizado ", PESQ);
Console.WriteLine("na posição {0}.", I + 1);
}
else
{
Console.WriteLine("{0} não foi localizado.", PESQ);
}
Console.ReadKey();
}
}
}
A operação de pesquisa é realizada com o método Array.IndexOf() que retorna um valor posi-
tivo se o conteúdo pesquisado for encontrado. Se a pesquisa não for bem-sucedida, esse método
retorna um valor negativo. Note que estamos atribuindo o valor da pesquisa junto à variável I que é
verificada na instrução if (i >= 0).
Outro detalhe a que devemos estar atentos é aos dois parâmetros do método Array.IndexOf,
sendo o primeiro parâmetro a variável indexada a ser pesquisada e o segundo parâmetro o conteúdo
a ser pesquisado.
5.5 Estrutura de registro

As estruturas (registros em outras linguagens de programação) possibilitam trabalhar com
dados heterogêneos, ou seja, dados de vários tipos em uma mesma tabela. Em linguagem de pro-
gramação C# isso é conseguido com o comando struct, que possibilita a criação de uma ficha virtual
para a manipulação de dados. Dessa maneira, conseguimos mesclar em uma mesma área de memó-
ria dados de tipos diferentes.
O comando struct permite uma estrutura de dados secundária, formada a partir da estrutura
de dados básica (primitiva ou primária) existente na linguagem de programação. Fica fácil reconhe-
cer na linguagem estruturas de dados que correspondam mais intimamente à realidade diária de tra-
balho, que possui a seguinte sintaxe:
struct [<nome do identificador>]
{
<qualificador> <lista dos tipos e seus membros>;
};
<nome identificador> <variável>;
Em que:
»» nome do identificador é o nome da estrutura (em outras linguagens esse mesmo recurso é
denominado registro) seguindo as mesmas regras de nomes para variáveis,
»» qualificador é a forma de visibilidade do recurso, que neste momento veremos apenas
como público, mas pode ser private (quando pode ser acessado dentro da classe a que
pertence), public (quando pode ser acessado fora da classe a que pertence), protected
(quando somente pode ser acessado pela classe a que pertence ou por suas classes-filho
que estejam herdando as características de comportamento da classe-pai). Essas questões
serão abordadas mais adiante, neste livro.
»» lista dos tipos e seus membros é a relação de tipos de dados que podem ser float, int, string,
entre outros, e a indicação das variáveis que serão usadas para o acesso à estrutura pro-
priamente dita.
Após indicar a estrutura, esta necessita ser associada a uma variável para representá-la,
seguindo uma estrutura de escrita semelhante à forma a seguir.
struct CAD_ALUNO
{
public string NOME;
public int SALA;
public float MEDIA;
};
A estrutura CAD_ALUNO tem como membros NOME, NOTA e MEDIA, que será um novo
tipo de dado (CAD_ALUNO), o qual está associado à variável ALUNO pela linha de código struct
CAD_ALUNO ALUNO;.
O acesso a cada membro de uma estrutura se dá com o operador ponto “.”. Assim, são acessos
válidos aos membros da estrutura CAD_ALUNO as referências ALUNO.NOME, ALUNO.SALA e
ALUNO.MEDIA. Essa forma pode ser usada em operações de entrada, processamento e saída.
É possível também considerar variáveis (como é o caso da variável ALUNO indicada anterior-
mente), sejam simples, sejam indexadas (matrizes), como sendo vetores de uma estrutura. A forma
vetorial de uma estrutura deve ser escrita da seguinte forma:
struct CAD_ALUNO
{
public string NOME;
public int SALA;
public float MEDIA;
};
CAD_ALUNO[] ALUNO = new CAD_ALUNO[<tamanho>];

Um detalhe importante que temos a considerar é que o código da estrutura deve ser definido
antes da função Main() e dentro da função em seu bloco é definido o código do programa.
Elabore um programa que efetue a entrada dos dados de oito alunos com nome, sala de aula
e média. Em seguida o programa deve apresentar no final um relatório com os dados alunos.
Execute o comando FILE/New Project, forneça o nome Cap05_Ex08 para o projeto e acione o
botão OK. Lembre-se de manter selecionada do lado esquerdo a sequência de opções Templates/
As instruções da estrutura deste programa devem ser escritas antes da função Main() e o códi-
go de manipulação dos dados deve ser definido dentro da função Main(). Observe em seguida
o trecho de código em negrito.
using System;
using System.Linq;
using System.Text;
{
class Program
{
public struct CAD_ALUNO

{
public string NOME;
public int SALA;
public float MEDIA;
};

{
CAD_ALUNO[] ALUNO = new CAD_ALUNO[8];

int I, J, LIN;
// Rotina para a entrada dos nomes, sala e media
for (I = 0; I <= 7; I++)

{
Console.Clear();
Console.WriteLine("Cadastro de Alunos");
Console.Write("Entre o {0}o. nome ...: ", I + 1);
ALUNO[I].NOME = Console.ReadLine();
Console.Write("Entre a sala .......: ");
ALUNO[I].SALA = Convert.ToInt32(Console.ReadLine());
Console.Write("Entre a media ......: ");
ALUNO[I].MEDIA = Convert.ToSingle(Console.ReadLine());
}
// Apresentação da tabela nome/sala/media
Console.Clear();
Console.WriteLine("Relatorio Geral");
Console.Write("Aluno");
Console.Write("Sala");
Console.WriteLine("Media");
LIN = 6;
for (I = 0; I <= 7; I++)
{
Console.SetCursorPosition(0, LIN);
Console.Write(ALUNO[I].NOME.ToUpper());
Console.Write("{0,4}", ALUNO[I].SALA);
Console.Write("{0,5:0.00}", ALUNO[I].MEDIA);
LIN++;
}
Console.ReadKey();
}
}
}

Observe o detalhe do local onde a struct é definida entre a classe Program e o método Main().
Note também a definição da variável ALUNO do tipo CAD_ALUNO. Veja que o tipo CAD_ALUNO
é um tipo de dado derivado, ou seja, um tipo de dado criado por nós para nosso uso.
Outra aplicação com estruturas de registro é a possibilidade de se fazer uso de uma matriz
dentro da estrutura. A definição dessa possibilidade ocorre de forma um pouco diferente da maneira
já apresentada. Assim, considere uma estrutura com nome, sala, quatro notas bimestrais e média
para oito alunos.
struct CAD_ALUNO
{
public string NOME;
public int SALA;
public float[] NT;
public float MEDIA;
};
Perceba que a linha de código public float[] NT define o espaço na memória para a criação
posterior do vetor a ser utilizado. A seguir veja um exemplo para manipular essa ocorrência.
Elabore um programa que efetue a entrada dos dados de oito alunos com nome, sala de aula e
notas bimestrais. Em seguida o programa deve apresentar no final um relatório com os dados
dos alunos incluindo-se neste a média de cada aluno. Execute o comando FILE/New Project,
forneça o nome Cap05_Ex09 para o projeto e acione o botão OK. Lembre-se de manter sele-
cionada do lado esquerdo a sequência de opções Templates/Visual Basic/Windows.
As instruções da estrutura deste programa devem ser escritas antes da função Main() e o códi-
go de manipulação dos dados deve ser definido dentro da função Main(). Observe em seguida
o trecho de código em negrito.
using System;
using System.Linq;
using System.Text;
{
class Program
{
public struct CAD_ALUNO
{
public string NOME;
public int SALA;
public float[] NT;
public float MEDIA;
};

{

int I, J, LIN;
float SOMA;
// Rotina para a entrada dos nomes e notas
for (I = 0; I <= 7; I++)

{
SOMA = 0;
ALUNO[I].NT = new float[4];
Console.Clear();
Console.WriteLine("Cadastro de Alunos");
Console.Write("Entre o {0}o. nome ...: ", I + 1);
ALUNO[I].NOME = Console.ReadLine();
Console.Write("Entre a sala .......: ");
ALUNO[I].SALA = Convert.ToInt32(Console.ReadLine());
for (J = 0; J <= 3; J++)
{
Console.Write("Entre a nota {0} .....: ", J + 1);
ALUNO[I].NT[J] = Convert.ToSingle(Console.ReadLine());
SOMA += ALUNO[I].NT[J];
}
ALUNO[I].MEDIA = SOMA / 4;
}
// Apresentação da tabela nome/notas/media
Console.Clear();
Console.WriteLine("Relatorio Geral");
Console.Write("Aluno");
Console.Write("Sala");
Console.WriteLine("Media");

LIN = 6;
for (I = 0; I <= 7; I++)
{
Console.Write(ALUNO[I].NOME.ToUpper());
Console.Write("{0,4}", ALUNO[I].SALA);
Console.Write("{0,5:0.00}", ALUNO[I].MEDIA);
LIN++;
}
Console.ReadKey();
}
}
}
Além da definição da reserva de espaço em memória para a criação da matriz indicada na

estrutura de registro no trecho de entrada do programa encontramos a instrução ALUNO[I].NT =
new float[4], que cria para cada ALUNO[I] uma instância com quatro posições para o campo NT.
Dessa forma, é possível fazer uso de um vetor dentro de uma estrutura de registro.
5.6 Foreach com matrizes

No capítulo anterior vimos o uso da instrução foreach para percorrer os controles de um for-
mulário, mas não é só para isso que ela é usada como mencionamos na ocasião, pois podemos usá-la
para percorrer os elementos de uma matriz, tanto de uma dimensão quanto de mais dimensões.
Vimos até este momento matrizes que são preenchidas por meio de trechos de códigos. No
entanto, podemos definir os elementos de uma matriz diretamente no código, como se fossem estru-
turas fechadas. Os programas deste tópico usam esta forma de operação.
Elabore um programa que tenha internamente uma matriz de uma dimensão (lista) com valo-
res numéricos entre 0 e 15 e que mostre quantos valores pares existem nessa lista. Execute o
Basic/Windows.
using System;
using System.Linq;
using System.Text;
{
class Program
{
{
int[] A = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
int SOMA = 0, R;
foreach (int I in A)
{
R = I % 2;
if (R == 0)
{
SOMA += 1;
}
}
Console.WriteLine("Resultado = {0}", SOMA);
Console.ReadKey();
}
}
}
Note no programa a definição da matriz A com seus elementos de maneira fechada no código
por meio da instrução int[] A = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}.
Observe que no programa para uso da instrução foreach está sendo definida a variável I com
int que percorrerá posição por posição (in) na matriz A. Um detalhe importante é que a definição do
tipo da variável I deve ser feita dentro do foreach como mostrado.

Com uso da mesma abordagem podemos definir matrizes, por exemplo, de duas dimensões,
como se segue.
Elabore um programa que tenha internamente uma matriz de duas dimensões (tabela) com
três linhas e cinco colunas com valores numéricos entre 0 e 14. O programa deve mostrar
quantos valores ímpares existem na tabela. Execute o comando FILE/New Project, forneça o
using System;
using System.Linq;
using System.Text;
{
class Program
{
{
int[,] A = new int[3, 5] {

{ 0, 1, 2, 3, 4},
{ 5, 6, 7, 8, 9},
{10,11,12,13,14}
};
int SOMA = 0, R;
foreach (int I in A)
{
R = I % 2;
if (R != 0)
{
SOMA += 1;
}
}
Console.WriteLine("Resultado = {0}", SOMA);
Console.ReadKey();
}
}
}
Neste exemplo a definição da matriz de duas dimensões foi didaticamente dividida em três
linhas, mas poderia ter sido definida em uma única linha. Observe os detalhes no uso das chaves e
das vírgulas. Outro detalhe é a definição da matriz com o trecho de código int[,] A = new int[3, 5].
Vamos recapitular?
Neste capítulo foi visto o uso das técnicas básicas com arranjos de valores. Foi apresentado o uso
de matrizes de uma dimensão e de duas dimensões para valores numéricos e sequências alfabéticas,
tanto em modo estático como dinâmico, além das operações de ordenação e pesquisa de elementos.
Agora é com você!
1) Desenvolva os programas dos seguintes problemas utilizando matrizes de uma

dimensão:
a) Ler oito elementos numéricos inteiros em uma matriz A do tipo vetor. Construir
uma matriz B de mesma dimensão com os elementos da matriz A multiplicados
por 3. Apresentar os elementos da matriz B.
b) Ler duas matrizes A e B do tipo vetor com 20 elementos numéricos inteiros.
Construir uma matriz C, sendo cada elemento de C a subtração do elemento
correspondente de A com B. Apresentar os elementos da matriz C.
c) Ler duas matrizes do tipo vetor A com cinco elementos e B com dez elementos
(valores numéricos inteiros). Construir uma matriz C, sendo esta a junção das
duas outras matrizes. Dessa forma, C deve ter a capacidade de armazenar 15 ele-
mentos. Apresentar os elementos da matriz C.
d) Ler 15 elementos numéricos inteiros de uma matriz A do tipo vetor. Construir
uma matriz B de mesmo tipo, observando a seguinte lei de formação: todo ele-
mento da matriz B deve ser o quadrado do elemento correspondente da matriz
A. Apresentar os elementos das matrizes A e B dispostos lado a lado.
e) Ler 20 elementos numéricos inteiros para uma matriz A do tipo vetor e cons-
truir uma matriz B de mesma dimensão com os mesmos elementos de A. Eles
devem estar invertidos, ou seja, o primeiro elemento de A passa a ser o último
de B, o segundo elemento de A passa a ser o penúltimo de B e assim por diante.
Apresentar os elementos das duas matrizes.

2) Desenvolva os programas dos seguintes problemas utilizando matrizes de duas
dimensões:
a) Ler duas matrizes A e B com valores inteiros cada uma de duas dimensões com
cinco linhas e três colunas. Construir uma matriz C de mesma dimensão, a qual
é formada pela soma dos elementos da matriz A com os elementos da matriz B.
Apresentar os elementos da matriz C.
b) Ler 20 elementos numéricos reais para uma matriz A, considerando que essa
matriz tenha o tamanho de quatro linhas por cinco colunas. Em seguida apre-
sentar os valores lidos.
c) Ler duas matrizes A e B com valores reais cada uma de duas dimensões com
quatro linhas e quatro colunas. Construir uma matriz C de mesma dimensão,
a qual é formada pela subtração dos elementos da matriz A dos elementos da
matriz B. Apresentar os valores da matriz C.
d) Ler 16 elementos numéricos reais para uma matriz A, considerando uma matriz
com quatro linhas por quatro colunas. Em seguida apresentar os valores existen-
tes na diagonal principal da matriz A.
e) Ler nove elementos numéricos reais para uma matriz A, considerando uma
matriz com três linhas por três colunas. Em seguida apresentar os valores exis-
tentes na diagonal principal da matriz A multiplicados por 2 e os demais ele-
mentos multiplicados por 3.

6
Programação
com Sub-rotinas
Para começar
Este capítulo mostra o uso das sub-rotinas (métodos) na linguagem C#. São apresentados elemen-
tos de trabalho com métodos e namespaces, além das instruções para definição e uso de métodos com e
sem retorno, passagens de parâmetros e funções e o uso de métodos para a efetivação de cálculos mate-
máticos e manipulação de cadeias de caracteres.
6.1 Métodos e namespaces

A linguagem C#, por operar no paradigma da orientação a objetos, segue uma estrutura ope-
racional, de certa forma parecida em alguns pontos, não em todos, com a programação estruturada.
As linguagens orientadas a objetos usam rotinas de ação denominadas métodos (ou funções-mem-
bro, dependendo da linguagem em uso) que nada mais são do que similares em programação estru-
turada denominados sub-rotinas (funções, procedimentos, módulos ou subprogramas).
Um método ou sub-rotina é um trecho de código de programa independente de qualquer
parte do programa, mas relacionado ao programa com atribuições bem definidas. Os métodos são
um conjunto de instruções que efetuam uma tarefa específica. De forma geral, os métodos podem
receber valores de entrada (parâmetros opcionais) e gerar opcionalmente um valor de saída (retor-
nar apenas um valor), denominado valor de retorno. Um método pode ser interno ou externo:
» Um método é interno quando faz parte dos recursos internos do compilador. O con-
junto dos métodos e até de classes internos formam o chamado namespace, que acompanha
101
o compilador propriamente dito e é disponibilizado pelo comando de acesso às bibliote-
cas da linguagem using.
» Um método é externo quando é desenvolvido e implementado por nós programadores e
pode ser associado diretamente a um programa ou indiretamente formando uma biblio-
teca particular de namespaces com recursos próprios.
A utilização de métodos torna o trabalho de desenvolvimento com linguagem C# algo bastante
versátil, já que:
» Em termos de modularidade, tem-se o programa dividido em vários módulos (divisão e
conquista), e cada módulo desempenha uma ação particular. Essa estratégia de programa-
ção facilita a manutenção dos programas construídos.
» O programador torna-se capaz de criar seus próprios pacotes de métodos pessoais,
fazendo com que a programação se torne mais eficiente, porque é possível aproveitar
códigos de programas que já foram testados e revisados anteriormente (sendo este um
dos conceitos básicos que norteiam o trabalho de desenvolvimento com programação
orientação a objetos), os quais podem ser usados sem problema em novos programas.
No geral, problemas complexos exigem algoritmos complexos, mas sempre é possível dividir
um problema grande em problemas menores. Dessa forma, cada parte menor tem um algoritmo
mais simples, e é esse trecho menor que na linguagem C# pode se tornar um método.
A primeira revista brasileira de microcomputadores foi a Micro Sistemas, publicada a partir de 1981. Teve 169
edições em 15 anos de publicação. Para conhecer alguns exemplares digitalizados dessa revista, consulte o site
http://www.datacassete.com.br/revistas/edicao/Micro-Sistemas/57.html (fev/2014).
Quando um método é chamado por um programa principal (ou por outra rotina ou mesmo
sub-rotina), ele é executado; e, ao seu término, o controle de processamento do programa retorna
automaticamente para a primeira linha de instrução após a linha que efetuou a chamada do método
em questão.
Além dos métodos internos, é possível criar os seus próprios métodos (métodos externos). A
construção de um método externo segue os mesmos cuidados de programação já estudados e aplica-
dos nos capítulos anteriores.
Na linguagem C# é possível desenvolver três formas de comportamento para um método.
O primeiro, quando o método é executado e não retorna nenhum valor para a rotina chamadora; o
segundo, quando um método tem a capacidade de retornar apenas um valor à função chamadora;
e, por último, quando um método trabalha com passagem de parâmetros por valor e por referência.
Mais adiante essas três formas serão apresentadas.
Um pacote de métodos, ou seja, um namespace, é um conjunto de recursos predefinidos exis-
tentes em um local para serem usados pelo programador e/ou desenvolvedor. Os recursos podem ser
utilizados a partir do comando using seguido do nome do namespace.

Fique de olho!
Assim como o Capítulo 5, vamos nos concentrar no uso da técnica e não na interface gráfica.
6.2 Definição de métodos

A partir de uma visão básica do que é método e após o uso de alguns métodos internos, você
vai aprender a criar os seus próprios métodos, que serão desenvolvidos com os mesmos cuidados de
programação já estudados e aplicados até esse momento. Um método externo definido pelo progra-
mador ocorre conforme a seguinte sintaxe:
<qualificador> <tipo> <nome> ([Parâmetros])

{
<corpo>;
Em que:
»» qualificador: caracteriza-se por ser uma palavra reservada da linguagem C#, o qual define
a visibilidade de um determinado atributo, método, objeto ou variável, sendo possível
usar como qualificadores os valores private (quando pode ser acessado dentro da classe a
que pertence), public (quando pode ser acessado fora da classe a que pertence), protected
(quando somente pode ser acessado pela classe a que pertence ou por suas classes-filho
que estejam herdando as características de comportamento da classe-pai). Como comple-
mentação do qualificador em uso, utiliza-se uma segunda cláusula opcional denominada
static que tem por finalidade indicar que o atributo, método, objeto ou variável pertence à
classe a ele associada.
»» tipo: é o tipo de dado de retorno do método após sua execução. Pode ser o nome de um tipo
primitivo da linguagem como: int, float, double, string, long, byte, entre outros. Se o
método não for retornar valor, deve-se usar a palavra reservada void.
»» nome: é o nome com o qual o método será chamado.
»» parâmetros: um ou mais elementos opcionais com os quais o método efetua a entrada
de valores para sua operação. Caso o método tenha mais de um parâmetro, separe-os
com vírgula.
»» corpo: é o código que executa a ação do método.
A linguagem C# não suporta métodos globais, como ocorre em outras linguagens de progra-
mação como Basic (Visual Basic), C e C++.
6.3 Uso de método sem retorno

Vamos ver a definição e o uso de um método na linguagem C# bem simples que demonstre ape-
nas os níveis de acesso. Quando um método é chamado o fluxo de execução do programa, é desviado
Programação com Sub-rotinas 103

para o método em questão e, após executar o método, o fluxo do programa retorna para o ponto de
chamada para dar continuidade à execução do programa.
Elabore um programa que apresente a mensagem “Execução do programa principal - 1” quan-
do executado no programa principal. O programa deve fazer uma chamada de método (sub-
-rotina) e quando esta estiver em execução deve apresentar a mensagem “Execução da sub-rotina
(método)”. Ao voltar para o programa principal, deverá ser apresentada a mensagem “Execução
do programa principal - 2”. Execute o comando FILE/New Project, forneça o nome Cap06_Ex01
para o projeto e acione o botão OK. Lembre-se de manter selecionada do lado esquerdo a sequên-
cia de opções Templates/Visual Basic/Windows.
o trecho de código em negrito a seguir.
using System;
using System.Linq;
using System.Text;
{
class Program
{
{
Console.WriteLine("Execucao do programa principal - 1");
SubRotina();
Console.WriteLine("Execucao do programa principal - 2");
Console.ReadKey();
}
public static void SubRotina()

{
Console.WriteLine("Execucao da sub-rotina");
}
}
}

Após executar o programa, apresenta-se a parte principal do código e do método definido.
Assim, surgem as mensagens:
Execucao do programa principal - 1

Execucao da sub-rotina
Execucao do programa principal – 2
Observe o método principal (programa principal) representado pelo método Main(). O

método SubRotina() citado dentro do método Main() é definido após o método Main(). Note
que os métodos Main() e SubRotina() pertencem ambos ao namespace Cap6_Ex01. O namespace
Cap06_Ex01 incorpora respectivamente os métodos Main() do programa principal e o método
SubRotina() que é a sub-rotina desenvolvida pelo programador.
Assim que o programa é executado, o namespace Cap06_Ex01 invoca (chama) automati-
camente o método Main() que em seguida executa e apresenta a primeira mensagem, depois o
método Main() invoca o método SubRotina(). Nessa etapa, ocorre o desvio do programa para
o método SubRotina(), apresentando a mensagem que se refere a ele. Após executar o método
SubRotina(), o fluxo de execução da sub-rotina é retornado ao módulo Main(). Nesse momento,
aparece a segunda mensagem do método Main().
Vejamos mais um exemplo no uso de métodos como sub-rotinas.
Elabore um programa que apresente uma calculadora para duas entradas de valores. O progra-
ma deve apresentar um menu com as quatro operações básicas; quando uma opção for escolhi-
da, o programa deve solicitar dois valores e mostrar o resultado da operação realizada. Execu-
te o comando FILE/New Project, forneça o nome Cap06_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.
Observe atentamente os trechos do programa escritos em negrito. Atente para o que é definido
antes e depois de Main().
using System;
using System.Linq;
using System.Text;
{
class Program
{

public static float R, A, B;
public static string MSG = "Tecle algo para continuar... ";

{
string OPCAO;
OPCAO = "0";
while (OPCAO != "5")
{
Console.Title = "Calculadora";
Console.BackgroundColor = ConsoleColor.Black;
Console.ForegroundColor = ConsoleColor.Green;
Console.Clear();
Console.WriteLine("Menu Principal");
Console.WriteLine("--------------");
Console.WriteLine("1 - Soma");
Console.WriteLine("2 - Subtracao");
Console.WriteLine("3 - Multiplicacao");
Console.WriteLine("4 - Divisao");
Console.WriteLine("5 - Fim de Programa");
Console.Write("Escolha uma opcao: ");
OPCAO = Console.ReadLine();
if (OPCAO != "5")
switch (OPCAO)
{
case "1": RotSoma(); break;
case "2": RotSubtracao(); break;
case "3": RotMultiplicacao(); break;
case "4": RotDivisao(); break;
default:
Console.WriteLine("Opcao invalida");
Console.Write(MSG);
Console.ReadKey();
break;
}
}
private static void Entrada()

{
Console.Write("Entre um valor para A: ");
A = Convert.ToSingle(Console.ReadLine());
Console.Write("Entre um valor para B: ");
B = Convert.ToSingle(Console.ReadLine());
}

private static void Saida()
{
Console.Write("O resultado entre A e B = {0:0.00}", R);
Console.Write(MSG);
Console.ReadKey();
}
private static void RotSoma()

{
Console.Clear();
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("Rotina de Soma");
Console.WriteLine("--------------");
Entrada();
R = A + B;
Saida();
}
private static void RotSubtracao()

{
Console.Clear();
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("Rotina de Subtracao");
Console.WriteLine("-------------------");
Entrada();
R = A - B;
Saida();
}
private static void RotMultiplicacao()

{
Console.Clear();
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine("Rotina de Multiplicacao");
Console.WriteLine("-----------------------");
Entrada();
R = A * B;
Saida();
}
private static void RotDivisao()

{
Console.Clear();
Console.ForegroundColor = ConsoleColor.Gray;
Console.WriteLine("Rotina de Divisao");

Console.WriteLine("-----------------");
Entrada();
if (B == 0)
{
Console.WriteLine("Erro.");
Console.Write(MSG);
Console.ReadKey();
}
else
{
R = A / B;
Saida();
}
}
}
}
O primeiro detalhe a ser observado é em relação às cláusulas public e static, utilizadas ao longo
do programa:
»» A cláusula static faz alusão à forma de comportamento de um método, atributo, objeto ou
variável armazenado na memória. Quando se usa a cláusula static, indica-se que o conteúdo
estático permanecerá em uma parte da memória, sendo visível a outros métodos, atributos,
objetos ou variáveis. Dessa forma, será possível usar esses recursos sem que seja necessário
definir novas instâncias. Observe as variáveis (objetos) R, A, B e MSG após a classe Program,
antes do método interno Main() e antes dos métodos externos de operação do programa.
»» A cláusula public determina que um recurso se torna público e assim é visível de forma
global na sua área de abrangência operacional. Essa forma é considerada a mais permis-
siva existente na linguagem C#. Uma forma de restringir acessos a recursos é com a cláu-
sula private. As partes marcadas como private somente podem ser usadas no código das
classes que estão sendo definidas, nesse caso somente na classe Program. Se fosse criada
uma segunda classe nesse programa, não teria acesso aos recursos privados da classe
Program, mas teria acesso e poderia usar os recursos que estão marcados como public.
A ausência do escopo de comportamento de um recurso como no método interno Main() faz
com que seja por padrão considerado o escopo private.
Antes do método interno Main(), são especificadas as variáveis de operação do programa.
Essas variáveis possuem o escopo de visibilidade como global, pois são as primeiras existentes antes
de o programa ser executado. Uma variável (ou objeto de escopo global) pode ser visualizada em

todo o programa. O mesmo não ocorre com uma variável ou objeto de visibilidade local, quando
definido dentro de um método, a qual só existirá na memória quando da execução do método por
uma variável local. Para uma variável ou objeto possuir visibilidade global, deve ser determinados
antes do método interno Main().
O código do método interno Main() apresenta um menu de seleção do programa. Para a
montagem desse menu foram usados alguns comandos e instruções conhecidas, mas foram tam-
bém utilizados comandos e instruções diferentes daqueles tratados ao longo deste trabalho. Por
exemplo, a instrução Console.Title = "Calculadora"; é usada para indicar um título de identifica-
ção para a janela apresentada. Esse título é exibido na barra de título da tela do programa quando
ele estiver em execução.
É pertinente fazer uma observação em relação à estrutura sintática do comando Console.Title,
em que Console é a classe e Title é uma propriedade da classe. Uma propriedade é diferente de um
método. O método é usado no sentido de se estabelecer uma ação a ser executada no programa. A
propriedade permite a escolha de uma possibilidade de ação. O método sempre volta um resultado
como resposta da ação com certo objeto; já a propriedade aplica uma opção no objeto em uso. Outro
detalhe é que um método possui como complemento sintático o uso de parênteses e a propriedade
se utiliza de uma operação de atribuição.
O comando Console.BackgroundColor, formado pela classe Console e a propriedade Background
Color, é usado para escolher a cor de fundo da tela. Nesse caso está sendo utilizado o valor de cor
ConsoleColor.Black (fundo preto). De forma semelhante, a instrução Console.ForegroundColor é
usada para definir a cor de apresentação do texto na tela do programa. Nesse caso utiliza para cada
rotina de ação do programa um valor de cor para a propriedade ForegroundColor diferente:
»» no método interno Main(), foi usado ConsoleColor.Green (texto escrito na cor verde);
»» no método externo RotSoma(), foi usado ConsoleColor.Cyan (texto escrito na cor azul);
»» no método externo RotSubtracao(), foi usado ConsoleColor.Yellow (texto escrito na cor
amarela);
»» no método externo RotMultiplicacao(), foi usado ConsoleColor.White (texto escrito na
cor branca);
»» no método externo RotMultiplicacao(), foi usado ConsoleColor.Gray (texto escrito na cor
cinza).
Para ver as opções de cores, basta prestar atenção ao momento de escrever a instrução e obser-
var a lista apresentada após usar o ponto.
As demais instruções existentes no programa são conhecidas e não carecem de explicação ou
explanação.
6.4 Passagem de parâmetros

O uso de passagem de parâmetros em um método proporciona uma comunicação bidirecional
entre as rotinas do programa, principalmente quando se utilizam variáveis de escopo local. Com as

variáveis de escopo global não é necessário usar tal recurso. É pertinente lembrar que as variáveis
locais só ocupam espaço em memória quando estão sendo utilizadas.
Quando se trabalha com métodos, é possível passar valores de uma sub-rotina para outra. Dessa
forma, pode-se passar valores de uma sub-rotina ou rotina chamadora a outra sub-rotina e vice-versa.
A passagem de parâmetro entre métodos poderá ser definida sob a ótica de dois comporta-
mentos: passagem de parâmetro por valor e passagem de parâmetro por referência, cujas aplicações em
C# veremos a seguir.
6.4.1 Passagem de parâmetro por valor

A passagem de parâmetro por valor ocorre quando uma sub-rotina envia um conteúdo para
outra sub-rotina e não passa à rotina que a chamou nenhum valor por parâmetro.
Elabore um programa que apresente o resultado da fatorial de um número qualquer. A entra-
da do valor a ser calculado deve ocorrer no programa principal o cálculo e a apresentação do
resultado deve ser efetuada dentro da sub-rotina. Execute o comando FILE/New Project, for-
neça o nome Cap06_Ex03 para o projeto e acione o botão OK. Lembre-se de manter seleciona-
da do lado esquerdo a sequência de opções Templates/Visual Basic/Windows.
using System;
using System.Linq;
using System.Text;
{
class Program
{
{
int X;
Console.Title = "Programa Fatorial";

Console.Write("Entre um valor numerico: ");
X = Convert.ToInt32(Console.ReadLine());
Fatorial(X);

Console.ReadKey();
public static void Fatorial(int N)

{
long FAT = 1;
if (N == 0)
{
FAT = 0;
}
else
{
for (int I = 1; I <= N; I++)
{
FAT *= I;
}
}
Console.WriteLine("Fatorial de {0} = {1}", N, FAT);
}
}
}
Usa-se a passagem de parâmetro por valor quando há necessidade de passar algum conteúdo
à sub-rotina chamada. O conteúdo passado pelo parâmetro na chamada da sub-rotina é copiado a
partir da chamada para a sub-rotina chamada. Qualquer modificação na variável local da sub-rotina
não afetará o valor do parâmetro passado, ou seja, o processamento é executado apenas na sub-
-rotina, ficando assim o resultado obtido “preso” na área de abrangência da sub-rotina chamada.
6.4.2 Passagem de parâmetro por referência

A passagem de parâmetro por referência ocorre quando uma sub-rotina envia um conteúdo
para outra sub-rotina e aguarda um retorno nesse parâmetro com um conteúdo processado.
Elabore um programa que apresente o resultado da fatorial de um número qualquer. A entrada
do valor a ser calculado deve ocorrer no programa principal e a apresentação do resultado da
fatorial também; o cálculo deve ser efetuado dentro da sub-rotina. Execute o comando FILE/
New Project, forneça o nome Cap06_Ex04 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.

using System;
using System.Linq;
using System.Text;
{
class Program
{
{
int X;
long Y = 1;

X = Convert.ToInt32(Console.ReadLine());
Fatorial(X, ref Y);
Console.WriteLine("Fatorial de {0} = {1}", X, Y);

Console.ReadKey();
public static void Fatorial(int N, ref long FAT)

{
if (N == 0)
{
FAT = 0;
}
else
{
for (int I = 1; I <= N; I++)
{
FAT *= I;
}
}
}
}
}

Observe a chamada da sub-rotina fatorial(X, ref Y) no trecho principal do programa. Note que
a sub-rotina fatorial() recebe a passagem de dois parâmetros: um parâmetro por valor, no caso X
para N, e outro parâmetro por referência, no caso Y com valor 1 para FAT.
Após a chamada da sub-rotina fatorial(), o valor da variável X é passado à variável N, e o valor
da variável Y é passado à variável FAT. Na medida em que o valor de FAT é alterado, a variável Y
passa a ter copiado automaticamente o valor da variável FAT.
6.5 Uso de método com retorno

Um método com retorno é uma estrutura que possui como característica operacional a
capacidade de sempre retornar um conteúdo como resposta, independentemente de fazer uso de
passagem de parâmetros por valor ou por referência.
Para cumprir o requisito de sempre retornar uma resposta uma sub-rotina do tipo função, faz
uso no final de um comando return com algum conteúdo de resposta associado a função. Uma típica
sub-rotina de função tem por finalidade, sempre, retornar um conteúdo como resposta, e para tal
feito deve ser definida com um dos tipos de dados primitivos da linguagem.
Elabore um programa que apresente o resultado da fatorial de um número qualquer. A entrada
do valor a ser calculado deve ocorrer no programa principal, e a apresentação do resultado da
fatorial também; o cálculo deve ser efetuado dentro do método que deverá devolver o resul-
tado via return. Execute o comando FILE/New Project, forneça o nome Cap06_Ex05 para o
projeto e acione o botão OK. Lembre-se de manter selecionada do lado esquerdo a sequência
using System;
using System.Linq;
using System.Text;

{
class Program
{
{
byte X;
long Y;

X = byte.Parse(Console.ReadLine());
Y = Fatorial(X);
Console.WriteLine("Fatorial de {0} = {1}", X, Y);

Console.ReadKey();
public static long Fatorial(byte N)

{
long FAT = 1;
if (N == 0)
{
FAT = 0;
}
else
{
for (int I = 1; I <= N; I++)
{
FAT *= I;
}
}
return FAT;
}
}
}
O método fatorial(), por meio da instrução return FAT, retorna o conteúdo final da variável
FAT, devolvendo-a ao programa principal, que fez a chamada à função fatorial. Esse recurso devolve
um valor de retorno. Se houver mais valores a serem retornados, torna-se necessário utilizar pas-
sagem de parâmetro por referência.

6.6 Métodos para cálculos matemáticos
Dentre os vários recursos existentes na linguagem C#, pode-se destacar a classe Math, que pos-
sui uma série de funções para auxiliar diversas operações matemáticas.
A classe Math possui propriedades e métodos, podendo-se destacar as propriedades E, PI e os
métodos trigonométricos Acos(), Asin(), Atan(), Cos(), Sin() e Tan(); métodos exponenciais Pow() e
Sqrt(); métodos logarítmicos Exp() e Log() e possui também um conjunto com métodos para mani-
pulação numérica, tais como Abs(), Floor(), Max(), Min() e Round().
O programa a seguir demonstra de forma geral o uso de alguns dos métodos da classe Math.
Ao lado de cada propriedade e método usado, consta o valor que será impresso após a execu-
ção do programa. Execute o comando FILE/New Project, forneça o nome Cap06_Ex06 para o
projeto e acione o botão OK. Lembre-se de manter selecionada do lado esquerdo a sequência
using System;
using System.Linq;
using System.Text;
{
class Program
{
{
Console.WriteLine(Math.Acos(-1)); // 3.14159265358979
Console.WriteLine(Math.Asin(-1)); // -1.5707963267949
Console.WriteLine(Math.Atan(1)); // 0.785398163397448
Console.WriteLine(Math.Sin(1)); // 0.841470984807897
Console.WriteLine(Math.Tan(4)); // 1.15782128234958
Console.WriteLine(Math.Pow(2, 3)); // 8
Console.WriteLine(Math.Sqrt(9.0)); // 3
Console.WriteLine(Math.Exp(1)); // 2.71828182845905
Console.WriteLine(Math.Log(3)); // 1.09861228866811
Console.WriteLine(Math.Abs(-9)); // 9
Console.WriteLine(Math.Floor(2.03)); // 2

Console.WriteLine(Math.Max(10, 3)); // 10
Console.WriteLine(Math.Min(10, 3)); // 3
Console.WriteLine(Math.Round(5.8)); // 6
Console.WriteLine(Math.PI); // 3.14159265358979
Console.WriteLine(Math.E); // 2.71828182845905
Console.ReadKey();
}
}
}
6.7 Métodos para cadeias de caracteres

As cadeias de caracteres são sequências alfanuméricas delimitadas como caracteres entre aspas
inglesas. A referência em idioma inglês a essa sequência de caracteres se faz com o termo string.3
Para o tratamento desse tipo de ação usam-se propriedades e métodos associados a um objeto (variá-
vel) do tipo string.
Para uma demonstração desse recurso usam-se a propriedade Lenght e os métodos ToLower(),
ToUpper() e Substring() que, respectivamente, apresentam o tamanho do string, o string escrito
com caracteres minúsculos, o string escrito com caracteres maiúsculos e a extração de partes de um
string. O método Substring() usa dois parâmetros, sendo o primeiro a posição do string a ser extraí-
da e o segundo parâmetro define a quantidade de caracteres a ser extraída.
O programa a seguir demonstra de forma geral alguns dos métodos de manipulação de sequên-
cias de caracteres. Ao lado de cada recurso, consta o valor que será impresso após a execução
do programa. Execute o comando FILE/New Project, forneça o nome Cap06_Ex07 para o pro-
3 O termo “string” no idioma inglês é um substantivo que pode ser usado tanto no gênero masculino como no gênero feminino,
ou seja, é um substantivo de dois gêneros. Como substantivo de gênero masculino refere-se a barbante, fio, cordel, colar, cordão ou
tendão. Como substantivo de gênero feminino refere-se a corda, fileira, nervura, série, carreira ou sequência. Na esfera de progra-
mação de computadores para os norte-americanos o termo é usado para fazer referência a um cordão (um colar) imaginário cujos
caracteres se encontram presos e delimitados por aspas. Assim, a forma correta de referência ao substantivo “string” é usá-lo no
gênero masculino. Dessa forma, deve-se mencioná-lo como sendo “um string” e não “uma string” como muitos o fazem, mesmo
sabendo que esse substantivo pode ser usado como gênero feminino.

using System;
using System.Linq;
using System.Text;
{
class Program
{
{
String TEXTO = "Computador";
Console.WriteLine(TEXTO.Length); // 10
Console.WriteLine(TEXTO.ToLower()); // computador
Console.WriteLine(TEXTO.ToUpper()); // COMPUTADOR
Console.WriteLine(TEXTO.Substring(0, 3)); // Com
Console.WriteLine(TEXTO.Substring(3, 4)); // puta
Console.WriteLine(TEXTO.Substring(7, 3)); // dor
Console.ReadKey();
}
}
}
Vamos recapitular?
Neste capítulo foi apresentado a técnica de uso de procedimentos, visibilidade de variáveis, pas-
sagens de parâmetros e funções.

Agora é com você!
1) Desenvolva os programas dos problemas indicados em seguida com a técnica de uso

de sub-rotinas no estilo procedimento com passagem de parâmetro por valor, proce-
dimento com passagem de parâmetro por referência e função com passagem de parâ-
metro por valor. Note que para cada exercício proposto deverão ser produzidas três
soluções diferentes. Procure resolver os exercícios de acordo com os modelos apre-
sentados neste capítulo.
a) Elaborar um programa que possua uma sub-rotina que permita apresentar o
somatório dos N (1+2+3+4+5+6+7+...+N) primeiros números inteiros. O valor
de N deve ser fornecido pelo usuário do programa.
b) Escreva um programa que utilize uma sub-rotina para calcular o retorno do
valor da série de Fibonacci a partir da posição indicada pela variável N. O valor
N será fornecido pelo usuário e o programa deve apresentar o valor da sequên-
cia correspondente ao termo N informado. Por exemplo, se informado 3 o pro-
grama retorna 2, se informado 6 o programa retorna 8 e assim por diante.
c) Criar um programa que por meio de uma sub-rotina calcule e apresente o valor
de uma prestação em atraso, utilizando a fórmula P = V + (V * (TX/100) * T).
No caso P representa prestação, V representa valor, TX representa taxa e T
representa tempo.

7
Programação
Orientada a Objeto
Para começar
Este capítulo apresenta detalhes introdutórios à programação orientada a objetos. São descritos os
conceitos essenciais do que são classe, estruturas, campos e métodos. São mostradas as ações necessárias
para a declaração de classes, criação e uso de objetos. Mostram-se recursos de acesso a métodos, encap-
sulamento, herança e polimorfismo.
7.1 Classes ou estruturas, campos e métodos

Na linguagem C# temos dois recursos básicos do sistema de tipos da plataforma .NET,
sendo a técnica de definição de classe e a técnica de definição de estrutura (apresentada no capí-
tulo 5 como estrutura de registro). Tanto a classe (representada por class) como a estrutura (repre-
sentada por struct) são unidades lógicas, em que podemos encapsular um conjunto desses dados,
que no caso particular das classes são os dados representados por campos, métodos, propriedades
e eventos.
As estruturas de dados como unidades lógicas class e struct são a base (um modelo) para a
definição de variáveis especiais que manipulam o que chamamos de objetos. A partir do momento
em que temos uma estrutura de dados definida (um tipo de dado derivado), podemos associar (ins-
tanciar) essa estrutura a uma variável, ou, melhor dizendo, um objeto. A diferença entre uma variá-
vel comum e uma variável objeto é que a variável comum manipula apenas o valor do dado e em um
objeto conseguimos manipular não só o valor do dado, mas o comportamento associado a esse dado.
119
Se fizermos a definição de uma classe ou estrutura com nome CadAluno este será o nome
do tipo que poderemos associar a certa variável. Assim, ao definirmos a variável ALUNO como sendo do
tipo CadAluno com a instrução CadAluno ALUNO teremos, nesse momento, um objeto ou a defi-
nição de uma instância do tipo de dado CadAluno. No entanto, podemos criar ou instanciar quantos
objetos quisermos a partir da classe definida. A cada instância que definimos poderemos ter valores
diferentes em suas propriedades e em seus campos.
Apesar de semelhantes, uma class difere de uma struct na forma como elas são gerenciadas
pela plataforma .NET. Assim:
»» Uma struct é um tipo de dado que se relaciona com a memória por valor. Quando uma
struct é definida, a variável a ela associada possui a cópia dos dados reais definidos na struct.
Quando a struct é atribuída a uma nova variável, o conteúdo da estrutura é copiado para
essa nova variável. Assim, se definirmos dez variáveis com base na mesma struct teremos
dez cópias da mesma estrutura em memória, uma para cada variável. As alterações feitas
nos dados de uma das variáveis não afetam os dados das demais variáveis porque cada variá-
vel instanciada usa uma cópia da área de memória definida pela struct;
»» Uma class é um tipo de dado que se relaciona com a memória por referência. Quando um
objeto é criado a partir de uma class a variável ao objeto associado possui apenas uma referên-
cia aos dados da class e não uma cópia dos dados, como acontece com uma struct. Quando
a class é atribuída a uma nova variável, o conteúdo da estrutura usado pela nova variável é
o mesmo referenciado para a variável anterior. Assim, se definirmos dez variáveis com base na
mesma class teremos dez variáveis referenciadas a partir do mesmo local de memória. As alte-
rações feitas nos dados de uma das variáveis refletirão automaticamente nas demais variáveis
porque todas as variáveis usam uma área comum de memória estabelecida pela class.
Precisamos ter em mente quando usarmos class ou struct. Em geral, uma class deve ser usada
quando desejamos modelar estruturas de dados complexas em que os dados que vamos usar serão
modificados logo após a criação do objeto a partir da class. Já uma struct pode ser usada para a
definição de estruturas de dados que sejam pequenas e para as quais não se tenha a necessidade de
modificar dados logo após a struct ser criada. É importante considerar que uma struct não permite
usar o conceito de herança. Esse conceito só é aplicado numa class.
Uma curiosidade em relação à programação orientada a objetos é que para definirmos um
objeto e nele fazermos nossas operações precisamos definir inicialmente uma estrutura de dado cha-
mada estrutura ou classe que deverá ser instanciada a um objeto. Logo, mais importante que o objeto
é a definição da estrutura de dado que será a base para a definição do objeto.
Dentro da unidade lógica (ou estrutura de dados) struct ou class devemos definir os dados
que serão manipulados no programa, sendo esses representados basicamente por campos (posi-
ções que representam o conteúdo a ser armazenado na unidade lógica, ou seja, as característi-
cas definidas na classe ou estrutura) e métodos (as sub-rotinas de procedimentos ou funções usadas
para validar e operacionalizar o conteúdo da unidade lógica, ou seja, as operações associadas a classe
ou a estrutura).
Os termos usados para referenciarmos campos e métodos nas linguagens de programação
orientada a objetos não são padronizados, e isso pode criar alguma confusão. Por exemplo, em

Object Pascal campo é campo e método é procedimento-membro ou função-membro; em C++
campo pode ser campo ou atributo e método é função-membro; em Java, campo é atributo e método
é método; em C# campo é campo ou field e método é método, mas é comum escutarmos campo ser
referenciado como atributo.
A informática no Brasil foi um processo que ocorreu entre duas etapas, a primeira entre 1958 e 1975 com a impor-
tação de tecnologia estrangeira e a segunda etapa, a partir, de 1976, com o surgimento e desenvolvimento de uma
indústria nacional. Para saber mais, consulte http://retroplayerbrazil.wordpress.com/uma-breve-historia-da-informatica-
-no-brasil/ (fe/2014).
Os campos de uma unidade lógica devem ser nomeados com substantivos por representarem
características. É comum serem chamados de atributos. No entanto, devemos ter o máximo de cui-
dado ao usar o termo atributo na linguagem C# para referenciar-se a campos, pois isso pode vir a
confundir-se com outro conceito em C# denominado atributo de objetos.
Os métodos de uma unidade lógica devem ser nomeados com verbos por representarem ações
a serem executadas, sendo estes um conjunto de instruções que efetuam uma tarefa específica e rela-
cionada ao tratamento do conteúdo definido para os campos.
Fique de olho!
Assim como nos Capítulos 5 e 6, vamos nos concentrar no uso da técnica e não na interface gráfica.
7.2 Declaração de classe e criação de objeto

Uma classe, como já dissemos, é um tipo de dado como são outros tipos de dados da lingua-
gem, mas com a diferença de esse tipo ser definido pelo programador. Segundo Guerreiro (2000,
p. 17), classes são tipos de dados derivados pelo programador com a finalidade de declarar objetos e
podem, em C#, ser definidas com a instrução:
class [<nome identificador>]

{
<qualificador> <lista dos tipos e seus campos>;
<qualificador> <lista dos métodos>;
};
Em que:
» nome identificador é o nome da unidade lógica que será a representação da classe.
» qualificador é a forma de visibilidade do recurso, que pode ser private (quando pode ser
acessado dentro da classe a que pertence), public (quando pode ser acessado fora da classe
a que pertence), protected (quando somente pode ser acessado pela classe a que pertence
ou por suas classes-filho que estejam herdando as características de comportamento da
classe-pai). Esse tema será visto no tópico encapsulamento.
Programação Orientada a Objeto 121

»» lista dos tipos e seus membros é a relação de tipos de dados que podem ser float, int, string,
entre outros, e a indicação das variáveis que serão usadas para o acesso à estrutura pro-
priamente dito.
Após modelarmos a unidade lógica de uma classe necessitamos criar a variável que será a
representante na memória do objeto instanciado. Isso é realizado com a linha de código:
<nome identificador> <variável> = new <nome identificador>();
em que variável do tipo nome identificador representará o objeto instanciado com o comando new
seguido do mesmo nome do identificador seguido de parênteses. Mais adiante saberemos o que
isso representa. Neste momento é o que precisamos saber para criar nosso primeiro objeto pro-
priamente dito.
A título de demonstração, considere, em seguida, uma classe simples denominada Caluno,
contendo os campos NOME e NOTA com tamanho definido para quatro elementos, a qual será
associada a um objeto chamado ALUNO.
class Caluno
{
public string NOME;
public float[] NOTA = new float[4];
}
Caluno ALUNO = new Caluno();
A referência a ser feita para acessar os atributos de um objeto utiliza um ponto separador.
Note, em seguida, a utilização do objeto ALUNO e a indicação dos membros de dados NOME,
NOTA[0], NOTA[1], NOTA[2] e NOTA[3].
ALUNO.NOME = "Augusto Manzano";

ALUNO.NOTA[0] = 9.5;
Até o momento, foram definidos apenas os atributos da classe Caluno, demonstrando

seu estado de ocorrência por meio das atribuições de valores, que são os eventos associados, mas
nenhum método foi ainda indicado. É válido lembrar que um método está relacionado à forma de
funcionamento de um objeto pertencente a uma classe, ou seja, o método é uma estrutura que pos-
sibilita a execução de uma operação, de modo que esse objeto tenha comportamento lógico, além do
comportamento de armazenamento de dados utilizado por meio dos membros de uma classe.

class Caluno
{
public string NOME;
public float MEDIA;
public float CalcMedia()
{
byte I;
float SOMA, MEDIA;
SOMA = 0;
for (I = 0; I <= 3; I++)
{
SOMA += NOTA[I];
}
MEDIA = SOMA / 4;
return MEDIA;
}
}
No trecho de código anterior, além do método CalcMedia, estamos definindo as variáveis

locais SOMA e MEDIA, ambas do tipo float, usadas para somar e guardar o valor da média calcu-
lada pelo método CalcMedia.
A partir dessa visão geral, considere o problema exemplo a seguir.
Elabore um programa que entre o nome e quatro notas escolares de um aluno. O programa
deve ao final apresentar o resultado da média do aluno. Para realizar essa tarefa, o programa deve
usar uma classe que tenha o nome e as notas como campo e o cálculo da média como método.
Para que uma classe seja definida em C#, acesse o comando de menu PROJECT/Add Class, na
caixa de diálogo Add New Item - Cap07_Ex01, Figura 7.1, informe o nome da classe Caluno
no campo Name e acione o botão Add. Será, então, apresentada a guia de entrada do código
Caluno.cs, Figura 7.2.

Figura 7.1 - Caixa de diálogo “Add New Item”.
Figura 7.2 - Tela para escrita de uma classe.
Escreva o código marcado em negrito a seguir dentro da classe Caluno junto às chaves do tre-
cho de código identificado como class Caluno em namespace Cap07_Ex01:

using System;
using System.Linq;
using System.Text;
{
class Caluno
{
public string NOME;
public float MEDIA;
{
byte I;
float SOMA, MEDIA;
SOMA = 0;
for (I = 0; I <= 3; I++)
{
SOMA += NOTA[I];
}
MEDIA = SOMA / 4;
return MEDIA;
}
}
}
Para usar uma classe, é necessário instanciar uma variável para definir o objeto em que se
especificam os acessos às suas propriedades. Assim, vamos definir uma linha de código Caluno
ALUNO = new Caluno(); nas chaves do método Main() dentro da classe Program, na guia
Program.cs, Observe o trecho marcado em negrito.
using System;
using System.Linq;
using System.Text;
{
class Program
{
{
Console.Write("Entre o nome ..: ");
ALUNO.NOME = Console.ReadLine();
Console.WriteLine("Entre as notas:");

for (int I = 0; I <= 3; I++)
{
Console.Write("{0}a. nota ......: ", I + 1);
ALUNO.NOTA[I] = Convert.ToSingle(Console.ReadLine());
}
ALUNO.CalcMedia();
Console.WriteLine("Nome ..........: {0}", ALUNO.NOME);
Console.WriteLine("Notas:");
for (int I = 0; I <= 3; I++)
{
Console.WriteLine("{0,5:0.00} ", ALUNO.NOTA[I]);
}
Console.WriteLine("Média .........: {0,5:0.00}", ALUNO.CalcMedia());
Console.ReadKey();
}
}
}
Para gravar o projeto, execute o comando FILE/Save All e, para executar o programa, use o
7.3 Encapsulamento e herança

O conceito de herança está relacionado ao fato de uma classe herdar de outra classe suas carac-
terísticas. Assim, uma classe-filho (subclasse) herda da classe-pai (superclasse) todos os campos
e métodos que sejam a ele públicos. Se os componentes de uma classe-pai forem privados não ocorrerá
a definição de herança, mas se os componentes forem protegidos estes serão herdados mas necessitarão
de métodos específicos para fazer o acesso de escrita e leitura nos campos associados. Esse modo de
visibilidade pública, privada ou protegida é chamado de encapsulamento.
A partir dessa possibilidade, podemos utilizar objetos mesmo que não conheçamos todos os seus
atributos ou métodos. Dessa forma, é possível desenvolver bibliotecas (namespaces) de classes e obje-
tos que possam ser utilizadas por terceiros. Imagine, por exemplo, uma namespace que trate recursos
de impressão com código de barras em que não é necessário saber como as classes e objetos foram
definidos e quais são os atributos. Apenas é necessário saber como eles funcionam, como são os seus
métodos. O conceito de encapsulamento decorre da necessidade de esconder recursos protegendo-
-os ou privando-os em relação ao seu uso. O encapsulamento proporciona estabelecer o conjunto de
recursos que podem ser visíveis ou invisíveis, os quais são definidos pelos qualificadores public, private
e protected.
Ao desenvolver um objeto, pode-se especificar que é possível ter o acesso que se deseja. Por
esta obra ser um estudo inicial da linguagem C#, estão sendo apresentados os qualificadores public e
private. Assim, considere o descrito a seguir:

» Pode-se definir acesso total a todos os seus recursos (atributos e métodos), que são quali-
ficados pelo tipo public.
» Pode-se definir recursos que somente sejam acessados por intermédio de um método
existente na própria classe, que são aqueles com qualificador do tipo private.
Como exemplo de herança, considere uma classe denominada CsalaAula (que será a classe-
-pai) com a propriedade (campo) SALA, e a classe Caluno já existente que será a classe filha, a qual
herdará da classe-pai a propriedade SALA.
Exercício resolvido (continuação)

Em complementação ao código apresentado, considere o trecho de programa a ser definido
na guia Caluno.cs acima da classe Caluno e observe detalhadamente os trechos em negrito no
código a seguir:
using System;
using System.Linq;
using System.Text;
{
class CsalaAula
{
public string SALA;
}
class CadAluno : CsalaAula

{
public string NOME;
public float MEDIA;
{
byte I;
float SOMA, MEDIA;
SOMA = 0;
for (I = 0; I <= 3; I++)
{
SOMA += NOTA[I];
}
MEDIA = SOMA / 4;
return MEDIA;
}
}
}

Para especificar a herança, usa-se o símbolo de dois pontos (:), que deve ser posicionado à
frente do nome da classe que herdará todas as propriedades e métodos definidos. Dessa forma,
a classe Caluno passa a ter acesso à propriedade SALA da classe CsalaAula como se a proprie-
dade SALA fosse da própria classe Caluno.
Na sequência junto às chaves do método Main() dentro da classe Program, na guia Program.cs
acrescente as linhas indicadas em negrito.
using System;
using System.Linq;
using System.Text;
{
class Program
{
{
Console.Write("Entre o nome ..: ");
Console.Write("Entre a sala ..: ");
ALUNO.SALA = Console.ReadLine();
Console.WriteLine("Entre as notas:");
for (int I = 0; I <= 3; I++)
{
ALUNO.NOTA[I] = Convert.ToSingle(Console.ReadLine());
}
ALUNO.CalcMedia();
Console.WriteLine("Nome ..........: {0}", ALUNO.NOME);
Console.WriteLine("Sala ..........: {0}", ALUNO.SALA);
Console.WriteLine("Notas:");
for (int I = 0; I <= 3; I++)
{
Console.WriteLine("{0,5:0.00} ", ALUNO.NOTA[I]);
}
Console.WriteLine("Média .........: {0,5:0.00}", ALUNO.CalcMedia());
Console.ReadKey();
}
}
}
Para gravar o projeto, execute o comando FILE/Save All e, para executar o programa, use o

No programa anterior vimos uma ação de herança. Quando usamos atributos públicos, a
herança é feita de forma automática. Mas na programação orientada a objetos devemos evitar o uso
de atributos públicos e concentrar nossos esforços em usar atributos privados (quando queremos dar
herança) e protegidos (quando não queremos dar herança). O uso de atributos públicos deverá ocor-
rer em situações muito, mas muito particulares mesmo.
O programa a seguir apresenta o uso qualificador private no estabelecimento de um atributo
privado para acesso ao campo MEDIA. Todo atributo que seja privado ou protegido não pode ser
acessado diretamente no objeto instanciado, pois para ter acesso serão precisos em média dois méto-
dos específicos para essa ação: um método para escrever e outro para ler o atributo privado ou prote-
gido. Esses métodos de acesso em C# podem ser definidos pelo programador ou então ele pode fazer
uso das estruturas internas de comandos get e set.
Elabore um programa que entre o nome e duas notas escolares de um aluno. O programa deve
ao final apresentar o resultado da média do aluno. Para realizar esta tarefa o programa deve usar
uma classe que tenha o nome e as notas como campos públicos; o campo do valor da média
deve ser privado. Execute o comando FILE/New Project, forneça o nome Cap07_Ex02 para o
projeto e acione o botão OK. Lembre-se de manter selecionada do lado esquerdo a sequência de
Para criar as classes de trabalho acesse o comando de menu PROJECT/Add Class. Na caixa de
diálogo Add New Item - Cap07_Ex02, informe o nome da classe CsalaAula e acione o botão
Add. Será, então, apresentada a guia de entrada do código CsalaAula.cs.
Coloque os símbolos de chaves da classe CsalaAula no trecho de código marcado em negrito:
using System;
using System.Linq;
using System.Text;
{
class CsalaAula
{
private string SALA;
public string AcessaSALA

{
get
{
return SALA;
}

set
{
SALA = value;
}
}
}
class Caluno : CsalaAula

{
public string NOME;
public float N1, N2;
private float MEDIA;
public float CalcMedia(float NT1, float NT2)

{
MEDIA = (NT1 + NT2) / 2;
return MEDIA;
}
public static bool CondAluno(float ALUMEDIA, double CORMEDIA)

{
bool CONDALUNO = true;
if (ALUMEDIA < CORMEDIA)
CONDALUNO = false;
return CONDALUNO;
}
}
}
Para usar uma classe, é necessário instanciar uma variável para definir o objeto em que se
especificam os acessos às suas propriedades. Assim, vamos definir uma linha de código
Caluno ALUNO = new Caluno(); nas chaves do método Main() dentro da classe Program,
na guia Program.cs, Observe o trecho marcado em negrito.
using System;
using System.Linq;
using System.Text;
{
class Program
{
{

float MEDIA;

Console.Write("Entre nome .....: ");
Console.Write("Entre sala .....: ");
ALUNO.AcessaSALA = Console.ReadLine();
Console.Write("Entre a nota 1 .: ");
ALUNO.N1 = Convert.ToSingle(Console.ReadLine());
Console.Write("Entre a nota 2 .: ");
ALUNO.N2 = Convert.ToSingle(Console.ReadLine());
Console.WriteLine("Nome ...........: " + ALUNO.NOME.ToUpper());
Console.WriteLine("Sala ...........: " + ALUNO.AcessaSALA);
MEDIA = ALUNO.CalcMedia(ALUNO.N1, ALUNO.N2);
Console.WriteLine("Media ..........: {0,5:0.00}", MEDIA);
Console.Write("Situacao .......: ");
if (Caluno.CondAluno(ALUNO.CalcMedia(ALUNO.N1, ALUNO.N2), 5.0))

Console.WriteLine("Aprovado");
else
Console.WriteLine("Reprovado");
Console.ReadKey();
}
}
}
Na classe CsalaAula estamos definindo o atributo de campo SALA como um elemento prote-
gido. Assim, esse campo não poderá ser usado diretamente no objeto instanciado. Seu uso ocorre de
forma indireta por métodos de acesso. Nesse caso, estamos criando para acesso um método simples
chamado AcessaSALA que por meio dos blocos get e set estabelece o acesso ao campo protegido.
Note que no bloco get (pegar) o valor do campo SALA é para ser usado e no bloco set (colocar) o
valor informado é colocado dentro do campo SALA por meio de value que é usado para receber a
entrada do valor efetuado e transferi-lo ao campo indicado.
Na classe Caluno o acesso ao campo MEDIA protegido é realizado pelo método CalcMédia
que foi definido por nós para essa finalidade.
O programa Cap07_Ex02 para acessar o campo SALA herdado pela classe Caluno da classe
CsalaAula faz uso do método AcessaSALA tanto para a entrada quanto para a saída do dado infor-
mado. Observe no código do programa em que se encontra a classe Caluno a proposta de três atri-
butos públicos, sendo NOME do tipo string e N1 e N2 do tipo float. Note o uso antes dos atributos
NOME, N1 e N2 do qualificador public. No entanto, observe o atributo MEDIA do tipo float como
sendo private. Nesse caso, o atributo MEDIA é privado e somente pode ser usado dentro da classe
CadAluno, ou seja, o atributo MEDIA não possui visibilidade externa, pois está encapsulado.

Após os atributos, são definidos os métodos CalcMedia() para o cálculo da média e Cond
Aluno() para a verificação da condição de aprovação do aluno. No método CalcMedia(), estão os parâ-
metros NT1 e NT2 que fornecem para o método os valores das notas apresentadas. Internamente,
o método CalcMedia() utiliza o atributo MEDIA para calcular e dar retorno do valor da média calcu-
lada de forma pública. O resultado da média é transferido pelo método CalcMedia() e não pelo atri-
buto MEDIA.
Enquanto na programação orientada a objeto os campos de uma classe devem possuir o nível
de encapsulamento definido como privado e protegido, os métodos de acesso aos campos protegidos
ou privados devem ser públicos.
7.4 Polimorfismo
O termo polimorfismo é uma tradução em português do termo análogo em inglês polymorphic,
que é a contração das palavras poly (muitos) e morphic (formas), ou seja, muitas formas. Na progra-
mação orientada a objetos, polimorfismo é a capacidade que um método de um objeto possui de as-
sumir formas diferentes para a sua execução. Polimorfismo é a capacidade de escrever métodos que se
comportem corretamente para objetos de tipos diferentes (JANSA, 1995), ou seja, é a capacidade de
estabelecer uma única interface para vários métodos membros.
O uso de polimorfismo na linguagem C# pode ocorrer a partir de três formas diferentes de
aplicação; são elas:
» polimorfismo paramétrico;
» polimorfismo de inclusão;
» polimorfismo de sobrecarga.
O polimorfismo paramétrico ocorre quando são utilizadas estruturas preestabelecidas de ope-
ração. Cada cenário possui uma ação preestabelecida. Assim, um objeto pode ser usado harmoniosa-
mente em diferentes cenários sem a necessidade de ser efetivamente modificado.
O polimorfismo de inclusão ocorre quando um recurso de uma classe-filho instancia um
recurso sobre a classe-pai. Essa é a forma mais simples de construção polimórfica, pois a classe-pai
herda algum recurso advindo da classe-filho.
O polimorfismo de sobrecarga ocorre quando são usados vários métodos com o mesmo nome
de identificação, mas que possuem número de parâmetros diferentes. Essa é a forma de polimor-
fismo mais simples, comum e essencial. Curiosamente, há profissionais na nossa área que não acei-
tam essa forma como sendo uma ação polimórfica.
O exemplo a seguir nos mostra o polimorfismo paramétrico. Considere um programa que
deve efetuar a entrada de valores num arranjo em que não se conhece de antemão o núme-
ro de elementos a serem inseridos. Execute o comando FILE/New Project, forneça o nome

using System;
using System.Linq;
using System.Text;
{
class Program
{
{
List<Object> LISTA = new List<Object>();
int T;
string N;
// Entrada dos nomes
Console.Write("Quantos nomes a entrar? ");

T = Convert.ToInt32(Console.ReadLine());
for (int I = 0; I < T; I++)
{
N = Console.ReadLine();
LISTA.Add(N);
}
// Apresentacao dos nomes
for (int I = 0; I < LISTA.Count; I++)
{
N = LISTA[I].ToString();
Console.WriteLine("{0,3}o. nome = {1}", I + 1, N);
}
Console.ReadKey();
}
}
}

O efeito de aplicação da operação de polimorfismo universal paramétrico no exemplo que
estamos apresentando ocorre com o uso da instrução List<Object> LISTA = new List<Object>();. A
classe List usa a classe Object para definir um objeto LISTA, o qual é instanciado a partir da classe
List<Object> por meio da cláusula new. O uso dos parênteses após a classe List<Object> diz ao com-
pilador que o número de elementos do arranjo não é conhecido, ou seja, é um arranjo do tipo dinâ-
mico cujo número de elementos a ser armazenado será controlado pelo programa.
O efeito de polimorfismo universal paramétrico ocorre com a classe Object definida para a
classe List. Perceba que a classe Object pode operar com qualquer tipo de dado. No programa, foi
escolhido operar com dados string para a variável N. Se for modificado o tipo da variável N para int,
float ou qualquer outro tipo, a lista de objetos continua operando sem modificar a classe Object para
outra. Nesse ponto, ocorre uma ação polimórfica, pois o objeto LISTA pode assumir qualquer tipo
de dado, desde que seja previamente avisado, pois a Object é uma classe genérica da linguagem C#.
Assim que o objeto LISTA está definido e instanciado, é possível efetuar o gerenciamento da
lista. O método Add() permite a entrada de dados na lista. A propriedade Count captura o número
de elementos existentes na lista.
O exemplo a seguir nos mostra o polimorfismo de inclusão. Considere um programa que exe-
cute um método da classe e depois um método da classe-filho, ambos com o mesmo nome.
Após a execução dos métodos de cada classe, far-se-á a sobreposição do método da classe-
-filho ao método da classe-pai, de forma que a classe-pai perca acesso ao seu próprio método e
assuma para execução o método da classe-filho. Execute o comando FILE/New Project, forne-
ça o nome Cap07_Ex04 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.
Entre a namespace Cap07_Ex04 e o início do código do método Main() antes da classe Program,
informe o trecho de código seguinte para as classes que serão usadas no programa. Essas classes
estão dentro do código principal do programa e não fora, como anteriormente.
class ClassePai
{
public virtual void Executa()
{
Console.WriteLine("Acao na classe-pai");
}
}
class ClasseFilho : ClassePai

{
public override void Executa()

{
Console.WriteLine("Acao na classe-filho");
}
}

Para conseguir o efeito de polimorfismo universal de inclusão de modo que uma classe-pai as-
suma recursos da classe-filho, é necessário que o recurso a ser sobreposto esteja na classe-pai
como virtual. Daí a instrução de declaração do método da classe-pai public virtual void Execu-
ta(). Raciocínio semelhante deve ser considerado no recurso com mesmo nome na classe-filho.
O recurso da classe-filho deve ser declarado com a capacidade de fazer sobreposição a um recur-
so virtual da classe-pai. Daí o fato de a instrução de declaração do método da classe-filho ser
public override void Executa(). O método override (sobreposição) será sobreposto ao método de
mesmo nome indicado como virtual.
Na sequência, entre as chaves do método Main() insira o trecho de código a seguir:
ClassePai PAI = new ClassePai();

ClasseFilho FILHO = new ClasseFilho();
PAI.Executa();
FILHO.Executa();
PAI = FILHO;
PAI.Executa();
Console.ReadKey();
No programa, observe duas classes, a classe ClassePai e a classe ClasseFilho, ambas possuindo
um método com mesmo nome, nesse caso, método Executa().
A classe-pai possui no seu método Executa() a capacidade de apresentar a mensagem Acao na
classe-pai>. Na classe-filho também há um método chamado Executa() que apresenta a men-
sagem Acao na classe filho. Ambas as classes possuem um método com mesmo nome, mas que
resultam em ações diferentes.
Observe os objetos PAI e FILHO e o método Executa() associado ao objeto PAI, que apresenta a
mensagem Acao na classe-pai. O método Executa() está associado ao objeto FILHO, que apre-
senta a mensagem Acao na classe-filho.
Na sequência encontra-se o objeto PAI sendo atribuído pelo objeto FILHO por meio da ins-
trução PAI = FILHO. O método Executa() da classe-filho torna-se sobreposto ao método Exe-
cuta() da classe-pai. Quando isso ocorre, o objeto PAI assume para ele o método Executa()
existente no objeto FILHO, perdendo acesso ao seu próprio método. Esse efeito parece de
herança, mas ocorre em sentido contrário.
Observe o código completo do programa Cap07_Ex04:
using System;
using System.Linq;
using System.Text;

{
class ClassePai
{
public virtual void Executa()
{
Console.WriteLine("Acao na classe-pai");
}
}
class ClasseFilho : ClassePai
{
public override void Executa()

{
Console.WriteLine("Acao na classe-filho");
}
}
class Program
{
{
ClassePai PAI = new ClassePai();

ClasseFilho FILHO = new ClasseFilho();
PAI.Executa();
FILHO.Executa();
PAI = FILHO;
PAI.Executa();
Console.Write("Tecle algo para encerrar... " );
Console.ReadKey();
}
}
}
Ao ser executado o programa anterior a ClassePai processa seu método Exwecuta() e a Classe-
Filho processa seu método Executa(). Nesse momento cada um dos objetos associados executou
seu método particular. No momento em que a instrução PAI = FILHO a ClassePai passa a processar
o método da classe-filho.
O exemplo a seguir nos mostra o polimorfismo de sobrecarga. Considere um programa que
forneça como resposta a área de algumas figuras geométricas. Esse programa deve estar con-
figurado por dois códigos distintos. Execute o comando FILE/New Project, forneça o nome

Entre a namespace Cap07_Ex05 e o início do código do método Main() antes da classe
Program, informe o trecho de código a seguir para as classes que serão usadas no programa.
Essas classes estão dentro do código principal do programa e não fora, como anteriormente.
public class CalcArea
{
public static long Area(int X)

{
long AREA = X * X;
return AREA;
}
public static double Area(float R, float H)

{
double AREA = R * R * 3.14159 * H;
return AREA;
}
public static int Area(int X, int Y, int Z)

{
int AREA = X * Y * Z;
return AREA;
}
Os métodos Area() da classe CalcArea apresentam apenas o qualificador public. Para os casos
em que os métodos serão sobrepostos, via polimorfismo ad hoc de sobrecarga, os métodos não
podem ser estáticos. Não se usa a cláusula static como ocorreu em outros exemplos.
Na sequência, nas chaves do método Main() insira o trecho de código a seguir:
CalcArea A = new CalcArea();
Console.WriteLine("Calculo de Areas");
Console.WriteLine("Quadrado ..: " + A.Area(5));
Console.WriteLine("Cubo ......: " + A.Area(5, 6, 7));
Console.WriteLine("Cilindro ..: " + A.Area(7, 3));
Console.ReadKey();
No código da classe CalcArea, observe os três métodos diferentes com o mesmo nome:
Área(). Cada método trata de uma forma diferente (mais de uma forma, é polimórfico) de
parâmetro e assim está capacitado a realizar uma tarefa diferente da outra. Quando da exe-
cução do programa, a seleção do método a ser usado ocorre automaticamente, e essa decisão
depende do número de parâmetros em uso no momento da chamada do método.

Observe o código completo do programa Cap07_Ex05:
using System;
using System.Linq;
using System.Text;
{
public class CalcArea

{
public long Area(int X)

{
long AREA = X * X;
return AREA;
}
public double Area(float R, float H)

{
double AREA = R * R * 3.14159 * H;
return AREA;
}
public int Area(int X, int Y, int Z)

{
int AREA = X * Y * Z;
return AREA;
}
class Program
{
{
CalcArea A = new CalcArea();
Console.WriteLine("Calculo de Areas");
Console.WriteLine("Quadrado ..: " + A.Area(5));
Console.WriteLine("Cubo ......: " + A.Area(5, 6, 7));
Console.WriteLine("Cilindro ..: " + A.Area(7, 3));
Console.ReadKey();

}
}
}
7.5 Aplicação gráfica

Vamos ver agora uma pequena aplicação com interface gráfica manipulando o cadastro de
aluno usado neste capítulo. Siga como orientado.
Visual Basic/Windows. Neste caso esteja atento a selecionar a opção para criação da interfa-
ce gráfica.
Na guia Form1.vb monte um formulário com cinco controles do tipo Label, cinco controles
TextBox e três controles Button (Button1 com propriedade Text alterada para Cadastrar, Button2
com propriedade Text alterada para Limpar e Button3 com propriedade Text alterada para
Exibir), como indicado na Figura 7.3. Altere também a propriedade Text do Form1 para Programa
Orientado a Objeto.
Figura 7.3 - Formulário com controles.
Para criar as classes de trabalho, acesse o comando de menu PROJECT/Add Class. Na caixa de
diálogo Add New Item - Cap07_Ex06, informe o nome da classe CsalaAula e acione o botão
Add. Será, então, apresentada a guia de entrada do código CsalaAula.cs. Coloque os símbolos
de chaves da classe CsalaAula no trecho de código marcado em negrito:

class Caluno
{
public string NOME;
public float MEDIA;
{
byte I;
float SOMA, MEDIA;
SOMA = 0;
for (I = 0; I <= 3; I++)
{
SOMA += NOTA[I];
}
MEDIA = SOMA / 4;
return MEDIA;
}
}
Após concluir a montagem do formulário e ter informado a estrutura da classe, torna-se

necessário preparar os eventos dos botões para a ação do programa. Assim, com um duplo cli-
que, acione o botão Cadastrar e informe o trecho de código sinalizado em negrito.

{
ALUNO.NOME = textBox1.Text;
ALUNO.NOTA[0] = Convert.ToSingle(textBox2.Text);
}
Acima do código da rotina button1_Click informe a linha de código a seguir:
de maneira que se tenha esta sequência de instruções:

{
ALUNO.NOME = textBox1.Text;
}

Para o botão Limpar, escreva as linhas a seguir indicadas em negrito:

{
textBox1.Clear();
textBox2.Clear();
textBox3.Clear();
textBox4.Clear();
textBox5.Clear();
}
Para o botão Exibir, escreva as linhas a seguir indicadas em negrito:

{
textBox1.Text = ALUNO.NOME.ToUpper();
textBox2.Text = Convert.ToString(ALUNO.NOTA[0].ToString("#0.00"));
}
O programa anterior demonstra, de forma simples, o uso de um objeto gerenciado por um pro-
grama com interface gráfica. Note que a codificação da classe é a mesma usada para um programa em
modo gráfico que um programa em modo texto.
Vamos recapitular?
Neste capítulo foram apresentadas as bases de programação orientada a objetos com o uso de clas-
ses, estruturas, campos, métodos, encapsulamento, herança e polimorfismo.

Agora é com você!
1) Desenvolver os programas dos problemas indicados a seguir. Procurar os exercícios

de acordo com os modelos apresentados neste capítulo.
a) Elaborar um programa que a partir de uma classe do tipo estrutura chamada Pes-
soa com os campos públicos Nome, Idade e Sexo estabeleça um objeto X para 10
elementos. O programa deve, por meio de um menu, dar a possibilidade de entrar
todos os elementos, de apresentar todos os elementos e de sair do programa.
b) Elaborar um programa que a partir de uma classe do tipo estrutura chamada Pes-
soa com os campos privados Nome, Idade e Sexo estabeleça um objeto X para 10
elementos. O programa deve, por meio de um menu, dar a possibilidade de entrar
todos os elementos, de apresentar todos os elementos e de sair do programa. Lem-
bre-se de estabelecer os métodos necessários para acesso a cada um dos campos.
c) Elaborar um programa que tenha uma classe chamada ContaCorrente com o
campo privado SALDO e os métodos públicos. Depositar e Sacar para um obje-
to chamado Banco. O trecho de código do programa deve começar o Saldo com
valor zero e apresentar um menu com as opções depositar, sacar e finalizar, além
de apresentar o valor do saldo atual da conta. À medida que forem selecionadas
as opções de ação do programa depositar e sacar, o saldo deve ser apresentado
sempre de forma atualizada.

Bibliografia
AMBLER, S. W. Object Primer. United Kingdom: SIGS Books, 1995.

BELLIS, M. Fortran: The First Successful High Level Programming Language. About.com Inven-
tors. Disponível em: <http://inventors.about.com/od/computersoftware/a/Fortran.htm>. Acesso em:
12 nov. 2013.
BUENO, A. D. Programação Orientada a Objetos em C++ (Apostila). Universidade Federal de
Santa Catarina, Laboratório de Meios Porosos e Propriedades Termofísicas e Núcleo de Pesquisa em
Construção, 12 dez. 2002. Disponível em: <http://www.lmpt.ufsc.br/~andre/>. Acesso em: 03 jun.
2003.
CARDELLI, L. & WEGNER, P. On Understanding Types, Data Abstraction, and Polymorphism.
Computing Surveys, vol 17, nº 4, p. 471-522, Dec. 1985.
DEITEL, H. M.; DEITEL, P. J. Java: Como Programar. 3. ed. Porto Alegre: Bookman, 2001.
FERREIRA, A. B. de H. Dicionário Aurélio Eletrônico. v. 1.4. Rio de Janeiro: Nova Fronteira, 1994.
FURLAN, J. D. Modelagem de Objetos através da UML: Análise e desenho orientados a objetos.
São Paulo: Makron Books, 1998.
GOSLIN, J.; JOY, B.; STEELE, G.; BRACHA, B. Java Language Specification. 3rd. Addison-Wesley,
2005.
GUERREIRO, P. J. V. D. Programação com Classes em C++. Lisboa: FCA, 2000.
HALVORSON, M. Microsoft Visual Basic 2008: Step by Step. Washington: Microsoft Press, 2008.
HOSTETTER, C. Survey of Object Oriented Programming Languages. University of California,
Berkeley, USA, 23 May 1998. Disponível em: <http://www.rescomp.berkeley.edu/~hossman/cs263/
paper.html>. Acesso em: 02 jun. 2003.
HOUAISS, A. Dicionário Eletrônico Houaiss da Língua Portuguesa v. 2.0a. Rio de Janeiro: Insti-
tuto Antônio Houaiss/Editora Objetiva, 2007.
JANSA, K. Sucesso com C++. São Paulo: Érica, 1995.
LEITE, M.; RAHAL JUNIOR, N. A. S. Programação Orientada ao Objeto: Uma abordagem didá-
tica. Disponível em: <http://www.ccuec.unicamp.br/revista/infotec/artigos/leite_rahal.html>. Acesso
em: 24 nov. 2008.
MANZANO, J. A. N. G. Estudo dirigido de Microsoft Visual Basic 2012. São Paulo: Érica, 2012.
MANZANO, J. A. N. G. Estudo dirigido de Microsoft Visual C# 2012. São Paulo: Érica, 2012.
MANZANO, J. A. N. G. Estudo dirigido de Visual Basic. 6. ed. São Paulo: Érica, 1999.
Bibliografia 143
MANZANO, J. A. N. G.; OLIVEIRA, J. F. de. Algoritmos: Lógica para desenvolvimento de progra-
mação de computador. 26.ed. São Paulo: Érica, 2012.
PACIEVITCH, Y. C#. Disponível em: < http://www.infoescola.com/informatica/c-sharp/>. Acesso
em: 1 out. 2013.
PORTAL EDUCAÇÃO. História e características da linguagem C#. Disponível em: < http://www.
portaleducacao.com.br/informatica/artigos/6137/historia-e-caracteristicas-da-linguagem-c>, 2008.
Acesso em: 1 out. 2013.
SOANES, C. Compact Oxford English Dictionary of Current English. UK: Oxford University
Press, 2003.
STRACHEY, C. Fundamental Concepts in Programming Languages: Lecture Notes. Copenhagen:
International Summer School in Computer Programming, 1967.
WIRFS-BROCK, R., et al. Designing Object-Oriented Software. New Jersey: Prentice-Hall, 1990.

Programação de Computadores C# PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Programação de Computadores C# PDF

Uploaded by

Copyright:

Available Formats

Programação de Computadores C#

José Augusto N. G. Manzano

Manzano, José Augusto N. G.

1. C# (Linguagem de programação para computadores)

Índices para catálogo sistemático:

Copyright © 2014 da Editora Érica Ltda.

Coordenação Editorial: Rosana Arruda da Silva

Seu cadastro é muito importante para nós

Contato com o editorial: editorial@editoraerica.com.br

Editora Érica Ltda. | Uma Empresa do Grupo Saraiva

A minha esposa Sandra e minha filha Audrey.

Capítulo 2 - Programação Sequencial............................................................................ 19

Capítulo 3 - Programação com Desvios......................................................................... 37

Capítulo 4 - Programação com Laços............................................................................ 59

Capítulo 5 - Programação com Matrizes........................................................................ 77

Capítulo 6 - Programação com Sub-rotinas.................................................................. 101

Capítulo 7 - Programação Orientada a Objeto............................................................... 119

1.1 Plataforma .NET

1.2 Breve histórico sobre C#

1.3 O ambiente de programação

Figura 1.1 - Ambiente de programação VS.

Figura 1.2 - Caixa de diálogo “New Project”.

Figura 1.3 - Tela de projeto em modo console.

1.4 Programação orientada a objetos

Amplie seus conhecimentos

Entre 1954 e 1968, surgiram as primeiras linguagens de programação de computadores de

1.5 Programação em modo gráfico ou em

Agora é com você!

2.1 Tipos de dados

Tabela 2.1 - ­­­Tipos de Dados Inteiros

Tipo de dado inteiro Faixa de abrangência Tamanho

Referência feita a variáveis instanciadas a partir de um

2 American Standard Code Information Interchange.

2.4 Operadores aritméticos

Tabela 2.2 - Operadores Aritméticos

Operador Operação Tipo Resultado

+ Manutenção de sinal Unário -

- Inversão de sinal Unário -

% 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

2.5 Expressões aritméticas

Ela deveria ser escrita como A = (B * H) / 2.

2.6 Estrutura de um programa na linguagem

2.7 Programas sequenciais

Figura 2.1 - Caixa de diálogo New Project.

Figura 2.3 - Apresentação da barra de ferramentas, lado esquerdo.

Figura 2.4 - Janela da barra de ferramentas fixada na área de trabalho.

A partir desse momento o formulário está monta-

private void button1_Click(object sender, EventArgs e)

Figura 2.8 - Tela do programa após seu funcionamento.

Figura 2.9 - Programa de soma de dois números.

Antes de seguirmos em frente, é interessante conhecermos as funções de conversão de tipos

Tabela 2.3 - Funções de Conversão de Tipos de Dados

Os dados alfanuméricos a serem convertidos em um formato de dado numérico não podem

Figura 2.10 - Alteração para Cálculo de Salário Líquido.

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

Tabela 2.4 - Códigos de controle de escape

1.5 Programação em modo gráfico ou em

Tabela 2.1 - Tipos de Dados Inteiros

Tabela 3.3 - Precedência de uso dos operadores lógicos

Tabela 3.5 - Tabela verdade para o operador lógico de disjunção inclusiva