Programação Orientada a Objetos II - Livro-Texto Unidade II

Prévia do material em texto

23
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Unidade II
Iniciaremos os nossos estudos apresentando técnicas de programação aplicando‑se a plataforma 
desktop. Iremos aprender como segregar a estrutura de código C# para que possamos garantir qualidade 
de desenvolvimento e performance de manutenção.
Entendendo as aplicações, torna‑se fácil entender os passos necessários para dar suporte a 
aplicações e identificar as diversas maneiras pelas quais essas aplicações Windows Form são fornecidas 
ou implementadas.
3 Linguagem de Programação C#
A linguagem de programação C# foi criada para que desenvolvedores pudessem atuar de maneira 
mais ágil com aplicações web. Dentre os pontos da linguagem, podemos destacar os seguintes:
•	 Linguagem	de	programação	orientada	a	objetos	ideal	para	desenvolvimento	de	aplicações	web.
•	 É	 considerada	 uma	 evolução	 do	 C++,	 do	 qual	 são	 utilizadas	 algumas	 características,	 como	
declarações, expressões e operadores.
•	 Utiliza	muitas	regras	de	programação	para	reduzir	a	possibilidade	de	erros.
•	 C#	também	tem	como	objetivo	permitir	o	desenvolvimento	de	qualquer	tipo	de	aplicação:	web 
service, aplicação Windows convencional, aplicações para serem executadas num palmtop ou 
handheld, aplicações para internet etc.
3.1 Histórico e curiosidades
•	 Criada	pela	Microsoft	especificamente	para	a	plataforma	.NET.
•	 Iniciada	em	1999	por	Anders	Hejlsberg	e	equipe,	com	nome	de	Cool.
•	 .NET	é	apresentada	em	2000	e	linguagem	Cool	é	renomeada	para	C#.
•	 O	símbolo	real	seria	o	♯, e não o #. Porém, devido a limitação de telas, fontes, teclados e alguns 
navegadores,	no	momento	da	normalização	junto	à	ECMA,	foi	feita	a	opção	pelo	#.
•	 Foi	criada	com	base	nas	linguagens	C++	e	Java.
•	 Tem	como	um	dos	principais	editores	o	Visual	Studio.
24
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
 Saiba mais
Para saber mais a respeito do tema, sugerimos a leitura do seguinte artigo:
ARAÚJO,	 E.	 C.	 Introdução	 à	 linguagem	 C#.	 DevMedia, Rio 
de	 Janeiro,	 [s.d.].	 Disponível	 em:	 <http://www.devmedia.com.br/
introducao‑a‑linguagem‑c/27711>.	Acesso	em:	9	jun.	2015.
3.2 microsoft Visual Studio
O	Microsoft Visual Studio	 é	 um	pacote	 de	 programas	 da	Microsoft	 para	 desenvolvimento,	
dedicado ao framework	.NET	e	às	linguagens	Visual	Basic	(VB),	C,	C++,	C#	e	J#.	Trata	também	de	
desenvolvimento web	na	plataforma	do	ASP.NET,	tendo	como	linguagens	mais	frequentes	VB.NET	
(Visual	Basic	.Net)	e	C#.
3.3 Herança
Trata‑se	 da	 característica	 mais	 poderosa	 e	 importante	 da	 orientação	 a	 objetos,	 pois	 permite	 o	
reaproveitamento	 de	 atributos	 e	 de	 métodos,	 otimizando	 o	 tempo	 de	 desenvolvimento.	 Com	 isso,	
podemos	reduzir	significativamente	a	linha	de	código.
O	conceito	de	herança	trabalha	com	o	conceito	de	superclasse	e	 subclasse.	A	superclasse	é	uma	
classe que possui classes derivadas a partir dela, chamadas de subclasses. Estas, ao serem derivadas de 
uma superclasse, herdam seus atributos e métodos.
Figura	9 – Diagrama de Classe
25
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
A	seguir	podemos	observar	alguns	exemplos	que	contextualizam	a	explicação	de	herança:
Exemplo 1
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication1
{
 class Program
 {
 static void Main(string[] args)
 {
 
 Console.WriteLine (“ Instancia da Classe Pessoa, {0}!”, Console.
ReadLine());
 __________.__________ pessoa = new Heranca.______________();
 pessoa._______ = “professor unip”;
 ______.idade = 40;
 
 Console.WriteLine (“Pessoa: Nome={0},Idade={1}”, __________.nome, 
pessoa.__________);
 Console.WriteLine();
 Console.WriteLine();
 
 Console.WriteLine(“ Instancia da Classe Aluno, {0}!”, Console.Read‑
Line());
 Heranca.___________ __________ = new Heranca.Aluno();
 _____________.nome = “Joaquim”;
 _____________.idade = 30;
 aluno.___________________ = “AX3601223‑1”;
 
 Console.WriteLine(“Aluno: Nome={0},Idade={1}, Matricula={2}”, alu‑
no._____, ____._____, _____._____);
 Console.WriteLine();
 Console.WriteLine(“ Fim, {0}!”, Console.ReadLine());
 }
 }
}
namespace Heranca
{
 public class _____________
 {
 //atributos
 public string __________;
 public int _____________;
 
 //construtor
 public _____________()
 {
 Console.WriteLine(“Construção do objeto Pessoa.”);
 } 
 }
26
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
 public class _____________ : _____________
 {
 //atributo
 public String __________________;
 
 //construtor
 public Aluno()
 {
 Console.WriteLine(“Construção do objeto Aluno.”);
 }
 }
}
Exemplo 2
using System;
namespace ConsoleApplication2
{
 class Program
 {
 static void Main(string[] args)
 {
 
 //Início‑com base na herança 
 Console.WriteLine(“ Instancia da Classe Pessoa, {0}!”, Console.Read‑
Line());
 ____________.___________ _________ = new ___________.______(“Joa‑
quim”);
 Console.WriteLine (“Pessoa: Nome {0}”,_________.__________);
 Console.WriteLine();
 
 Console.WriteLine(“ Instancia da Classe Aluno com base na herança, 
{0}!”, Console.ReadLine());
 __________.________ aluno = new HerancaBase.__________(“090909‑x”, 
“Silva”);
 Console.WriteLine(“Aluno com nome {0} e matrícula {1}», aluno.nome, 
aluno.matricula);
 //Fim‑com base na herança
 Console.WriteLine(“ Fim, {0}!”, Console.ReadLine());
 }
 }
}
namespace HerancaBase
{
 public class __________
 {
 //atributos
 public string _________;
27
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
 public int ____________;
 //construtor
 public __________()
 {
 //nada
 }
 public Pessoa(string n)
 {
 this.nome = n;
 Console.WriteLine(“Construção do objeto Pessoa com parâmetro.”);
 }
 }
 public class _________ : ___________
 {
 //atributo
 public String ____________;
 //construtor com base na herança
 public Aluno(string m, string n)
 : base(n)
 {
 this.matricula = m;
 Console.WriteLine(“Construção do objeto Aluno com base na herança.”);
 }
 }
}
3.4 Polimorfismo
O	conceito	está	associado	à	herança	e	trabalha	com	a	redeclaração	de	métodos	previamente	herdados	
por	uma	classe.	O	ponto	principal	é	evitar	ter	de	modificar	o	código‑fonte;	 inserindo	uma	chamada	
em um método com um nome diferente, redeclara‑se o método com o mesmo nome declarado na 
superclasse.
A	seguir	podemos	observar	alguns	exemplos	que	contextualizam	a	explicação	de	polimorfismo:
Exemplo 1
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication3
{
 classProgramP
 {
 static void Main(string[] args)
 {
28
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
 Console.WriteLine(“ Instancia da Classe Familia, {0}!”, Console.
ReadLine());
 _________._________ familia = new _____________.__________();
 familia.pais();
 Console.WriteLine(“ Instancia da Classe Continente, {0}!”, Console.
ReadLine());
 ______________.Continente ____________ = new Polimorfismo. 
_______________();
 continente.________();
 Console.WriteLine(“ Instancia da Classe Hemisferio, {0}!”, Console.
ReadLine());
 Polimorfismo.Hemisferio ______________ = new Polimorfismo.Hemisferio();
 ____________.pais();
 Console.ReadLine();
 }
 }
}
namespace Polimorfismo
{
 public class ______________
 {
 public virtual void ___________()
 {
 Console.WriteLine(“ Método ‘pais’ do objeto ‘Familia’ “);
 }
 }
 //utilizando o método com o mesmo nome em classes diferentes
 class ____________ : Familia
 {
 public override void ________()
 {
 Console.WriteLine(“ Método ‘pais’ do objeto ‘Continente’ “);
 }
 }
 //utilizando o método com o mesmo nome em classes diferentes
 class Hemisferio : _____________
 {
 public override void _________()
 {
 Console.WriteLine(“ Método ‘pais’ do objeto ‘Hemisferio’ “);
 }
 }
}
Figura	10	–	Tela	Windows	Form
29
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Figura	11	–	Tela	Windows	Form:	Label
Figura	12	–	Tela	Windows	Form:	CheckBox selecionado
Exemplo 2
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication1
{
 public partial class Form1 : Form
 {
 public Form1()
 {
 InitializeComponent();
 checkBox1.Checked = false;
 label1.Text = “”;
 }
 
 private void button1_Click(object sender, EventArgs e)
 {
 Polimo.Movimenta __________ = new Polimo.Movimenta();
 if (this.checkBox1.Checked){
 _________.carro_em_movimento(new Polimo._______());
 label1.Text = “O Carro está acelerando.”;
 }
 else
30
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
 {
 movimenta.carro_em_movimento(new Polimo.________());
 label1.Text = “O Carro está freando.”;
 } 
 }
 }
}
namespace Polimo
{
 //Classe
 public abstract class Carro
 {
 public abstract bool __________();
 }
 //Classe
 public class Acelerar:Carro 
 {
 //Usa o mesmo nome do método da Classe Carro 
 public ______________ bool _________()
 {
 Console.WriteLine(“O Carro está acelerando.”);
 return true;
 }
 }
 
 //Classe
 public class Frear:Carro
 {
 //Usa o mesmo nome do método da Classe Carro 
 public override bool acao()
 {
 Console.WriteLine(“O Carro está freando.”);
 return true;
 } 
 }
 
 //Classe
 public class Movimenta
 {
 public bool carro_em_movimento(_________ car)
 {
 return car.___________();
 }
 }
} 
Exemplo 3
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication2
{
 class Programh
31
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
 {
 static void Main(string[] args)
 {
 //Início‑com base na herança 
 Console.WriteLine(“ Instancia da Classe Pessoa, {0}!”, Console.Read‑
Line());
 HerancaBase.Pessoa pessoa = new HerancaBase.Pessoa(“LUIZ”);
 Console.WriteLine(“Pessoa: Nome {0}”, pessoa.nome);
 Console.WriteLine();
 Console.WriteLine(“ Instancia da Classe Aluno com base na herança, 
{0}!”, Console.ReadLine());
 HerancaBase.Aluno aluno = new HerancaBase.Aluno(“090909‑x”, “Lui‑
gi”);
 Console.WriteLine(“Aluno com nome {0} e matícula {1}”, aluno.nome, 
aluno.matricula);
 //Fim‑com base na herança
 Console.WriteLine(“ Fim, {0}!”, Console.ReadLine());
 }
 }
}
namespace HerancaBase
{
 public class Pessoa
 {
 //atributos
 public string nome;
 public int idade;
 //construtor
 public Pessoa()
 {
 //nada
 }
 public Pessoa(string n)
 {
 this.nome = n;
 Console.WriteLine(“Construção do objeto Pessoa com parâmetro.”);
 }
 }
 public class Aluno : Pessoa
 {
 //atributo
 public String matricula;
 //construtor com base na herança
 public Aluno(string m, string n)
 : base(n)
 {
 this.matricula = m;
 Console.WriteLine(“Construção do objeto Aluno com base na her‑
ança.”);
 }
 }
}
32
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Exemplo 4
using System;
namespace ConsoleApplication3
{
 class ProgramP
 {
 static void Main(string[] args)
 {
 Console.WriteLine (“ Instancia da Classe Familia, {0}!”, Console.
ReadLine());
 Polimorfismo.Familia familia = new Polimorfismo.Familia();
 familia.pais();
 Console.WriteLine(“ Instancia da Classe Continente, {0}!”, Console.
ReadLine());
 Polimorfismo.Continente continente = new Polimorfismo.Continente();
 continente.pais();
 Console.WriteLine(“ Instancia da Classe Hemisferio, {0}!”, Console.
ReadLine());
 Polimorfismo.Hemisferio hemisferio = new Polimorfismo.Hemisferio();
 hemisferio.pais();
 Console.ReadLine();
 }
 }
}
namespace Polimorfismo
{
 public class Familia
 {
 //método pais [País ou Pais]
 public virtual void pais()
 {
 Console.WriteLine (“ Método ‘pais’ do objeto ‘Familia’ “);
 }
 }
 //utilizando o método com o mesmo nome em classes diferentes
 class Continente : Familia
 {
 public override void pais()
 {
 Console.WriteLine (“ Método ‘pais’ do objeto ‘Continente’ “);
 }
 }
 //utilizando o método com o mesmo nome em classes diferentes
 class Hemisferio : Familia
 {
 public override void pais()
 {
 Console.WriteLine (“ Método ‘pais’ do objeto ‘Hemisferio’ “);
 }
 }
33
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
 
Figura	13	–	Tela	Windows	Form	–	Label
Figura	14	–	Tela	Windows	Form	–	CheckBox selecionado
Exemplo 5
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication1
{
 public partial class Form1 : Form
 {
 public Form1()
 {
 InitializeComponent();checkBox1.Checked = false;
 label1.Text = “”;
 }
 private void button1_Click(object sender, EventArgs e)
 {
 Polimo.Movimenta movimenta = new Polimo.Movimenta();
 if (this.checkBox1.Checked)
 {
34
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
 movimenta.carro_em_movimento(new Polimo.Acelerar());
 label1.Text = “O Carro está acelerando.”;
 }
 else
 {
 movimenta.carro_em_movimento(new Polimo.Frear());
 label1.Text = “O Carro está freando.”;
 }
 }
 }
}
namespace Polimo
{
 //Classe
 public abstract class Carro
 {
 public abstract bool acao();
 }
 //Classe
 public class Acelerar : Carro
 {
 //Usa o mesmo nome do método da Classe Carro 
 public override bool acao()
 {
 Console.WriteLine(“O Carro está acelerando.”);
 return true;
 }
 }
 //Classe
 public class Frear : Carro
 {
 //Usa o mesmo nome do método da Classe Carro 
 public override bool acao()
 {
 Console.WriteLine(“O Carro está freando.”);
 return true;
 }
 }
 //Classe
 public class Movimenta
 {
 public bool carro_em_movimento(Carro car)
 {
 return car.acao();
 }
 }
}
4 Camada de aPreSentação
Em primeiro lugar, é importante sabermos que a Camada de Apresentação é a entrada de dados 
de	uma	aplicação.	Em	muitos	momentos	ela	é	apresentada	em	projetos	de	software como Front‑End, 
definida como protótipo na fase de levantamento de requisitos.
35
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Figura	15 – Camada de Apresentação
Quadro 2 – Relação Controle versus Tela
Controle Name do Controle Text do Controle
Form frmNotasUnip Cadastro	de	Notas
GroupBox1 grpNotasSemestre Notas	do	Semestre
Label1 lblNotasP1 NotaP1:
Label2 lblNotasP2 NotaP2:
Label3 lblMedia Média:
ComboBox1 cbxNotaP1 ‑
ComboBox2 cbxNotaP2 ‑
GroupBox2 grpExameFinal Exame Final
Label4 lblNotaExame Nota	Exame:
Button1 btnCalcularMedia Calcular	Mé&dia
Button2 btnLimpar Lim&par
Button3 btnSair Sai&r
Button4 btnCalcularExame Calcular &Exame
 Saiba mais
Para saber mais sobre esse assunto, sugerimos a leitura do artigo:
JOMORI,	S.	M.;	VOLPE,	R.	L.	D;	ZABEU,	A.	C.	P.	Qualidade	de	software.	
Revista	Banas	Qualidade,	São	Paulo,	ano	13,	n.	141,	fev.	2004.
36
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
4.1 Funções específicas da Camada de apresentação
A camada de apresentação é responsável por diversas funções importantes no processo de execução 
do software:
•	 Pode	ser	categorizada	por	processos	de	aplicação.
•	 Processamento	de	transações.
•	 Acesso	a	banco	de	dados.
•	 Gerência	de	ações	sistêmicas	etc.
 observação
Software ou aplicação podem, por meio de uma boa análise efetuada, 
gerar	frutos	excepcionais.	Uma	boa	análise	equivale	a	80%	da	execução	de	
um	projeto,	restando	apenas	20%,	que	se	destinam	à	programação.
Estudar	uma	linguagem	específica	garante	conhecimento	da	tecnologia,	
ou	 seja,	 ganho	 técnico.	 Porém,	 se	 a	 análise	 não	 andar	 em	paralelo	 com	
o	 código,	não	 será	possível	 aplicar	 todo	o	 conhecimento	 técnico	para	o	
sucesso da execução do desenvolvimento do software	e/ou	da	aplicação.
A camada de apresentação contém os elementos da interface do usuário do site e inclui toda a 
lógica,	que	compreende	a	interação	do	visitante	e	das	regras	de	negócio	(Windows	Form).
Podemos	definir	a	Camada	de	Apresentação,	ou	Camada	do	Cliente,	ou	até	mesmo	Camada	Superior,	
como	a	interface	com	o	usuário,	que	poderia	ser	considerada	até	mesmo	como	as	janelas	do	Windows	
do nosso aplicativo, por exemplo.
Essa	camada	interage	com	a	Camada	de	Controle	(intermediária)	para	fazer	solicitações	e	recuperar	
informações da camada de dados, exibindo‑as para os usuários.
Uma	segregação	de	camadas	certamente	deixa	o	código	com	uma	leitura	e	um	controle	mais	fáceis,	
pois toda a regra está alocada em uma camada isolada.
4.2 Criando a Camada de apresentação
Iremos	apresentar	como	será	feita	a	criação	da	nossa	primeira	camada	de	apresentação.	A	princípio	
será criado um form para que possamos conhecer alguns componentes.
Como	primeiro	passo,	abriremos	nosso	IDE	de	programação,	chamado	Microsoft	Visual	Studio.
37
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
 observação
Neste	livro‑texto	iremos	utilizar	o	Microsoft	Visual	Studio	2012.	Todo	e	
qualquer	exemplo	e/ou	exercício	deverá	ser	executado	nessa	versão	ou	em	
uma superior.
Figura	16	–	IDE	de	programação	Microsoft	Visual	Studio	2012
 Lembrete
Para	 efeito	 de	 padronização	 e	 arquitetura	 de	 solução,	 a	 estrutura	
de desenvolvimento de softwares	 terá	 como	 referência	 o	 MVC	 (Model,	
View,	Controller),	conforme	mencionado	anteriormente.	No	entanto,	essa	
arquitetura	 dará	 ao	 estudante	 uma	 visualização	 melhor	 sobre	 todos	 os	
recursos	utilizados	neste	livro‑texto.
Podemos	destacar,	dentro	do	Microsoft	Visual	Studio,	pontos	que	são	essenciais	para	a	execução	de	
um bom trabalho para o desenvolvedor:
•	 Solution	 Explorer (Gerenciador de Soluções): aba em que irá ficar concentrada toda 
a nossa estrutura de aplicação, desde a camada de apresentação até as classes que serão 
utilizadas	na	aplicação.
38
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Figura	17	–	Solution	Explorer:	Gerenciador	de	Soluções
•	 Toolbox	(Barra	de	Ferramentas):	utilizada	para	que	o	desenvolvedor	possa	criar	suas	telas	com	
base	em	protótipos	elaborados	na	fase	de	levantamento	de	requisitos	do	projeto	de	software.
Figura	18	–	ToolBox:	Barra	de	Ferramentas
Para	criamos	um	projeto	Windows	Form,	ou	seja,	um	projeto	em	que	a	premissa	será	elaborar	uma	
aplicação que será executada em ambiente desktop, teremos de seguir estes passos:
•	 Ao	iniciar	o	Microsoft	Visual	Studio,	devemos	acionar	o	link New	Project	(Novo	Projeto),	ou	no	
menu superior File	(Arquivo)	 New	(Novo)	Project	(Projeto).
39
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Figura	19	–	Tela	inicial	para	adicionar	um	novo	projeto
Figura	20	–	Rota	de	menu	para	adicionar	um	novo	projeto
 observação
A	 versão	 do	 Microsoft	 Visual	 Studio	 utilizada	 para	 ilustração	 deste	
livro‑texto	está	em	inglês.	O	autor	recomenda	a	utilização	dessa	versão,	pois	
ela é encontrada na maioria das empresas que atuam com desenvolvimento 
de software.
40
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
•	 Após	executar	a	ação	anterior,	a	seguinte	tela	deverá	ser	apresentada:
Figura	21	–	Caixa	inicial	de	criação	de	um	novo	projeto
Na	figura,	podemos	nos	atentar	para	alguns	detalhes,	tais	como:
•	 Do	lado	esquerdo	existe	um	item	chamado	Templates, onde podemos, por exemplo, definir em 
qual	linguagem	iremos	atuar.	É	muito	importante	atentarmos	à	linguagem	escolhida	para	que,	no	
momento da codificação, não possamos programar em linguagens diferentes.
Figura	22	–	Aplicação	Visual	Basic	com	código	C#
41
Re
vi
são:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Figura	23 – Templates	contidos	dentro	do	Visual	C#
Podemos notar que existem diversos templates,	porém	o	que	 iremos	utilizar	será	o	Windows 
Form Application.
Para	que	possamos	finalizar	o	processo	de	criação	do	nosso	projeto,	será	necessário	atentar	para	
mais alguns itens:
•	 Name	(Nome):	nome	que	será	colocado	no	projeto	desenvolvido.
•	 Location	(Localização):	onde	ficará	alocado	o	novo	projeto.
•	 Solution	Name	(Nome	da	Solução):	será	replicado	o	Name	(Nome)	informado	para	o	novo	projeto.
 observação
Recomendamos que nunca informe um diretório de pen drive para 
salvar	ou	abrir	um	projeto	Windows	Form.	Como	parte	das	boas	práticas,	o	
projeto	deve	ser	criado	e/ou	alocado	em	disco	local	e	só	depois	de	todas	as	
alterações efetuadas ser transferido para o pen drive.
42
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Figura	24	–	Definição	do	projeto	inicial
Após a execução desse passo será apresentada a seguinte tela:
Figura	25 – Ambiente de Desenvolvimento Windows Form
Quando	 um	 projeto	 Windows	 Form	 é	 adicionado,	 temos	 a	 visualização	 do	 Form1,	 que	 é	
adicionado automaticamente.
O	 Form1	nada	mais	 é	 do	 que	 a	 tela	 onde	 o	 desenvolvedor	 irá	 adicionar	 todos	 os	 componentes	
necessários para a sua funcionalidade.
Existe	 também,	 dentro	 do	 projeto	Windows	 Form,	 a	 aba	 Solution	 Explorer, que detalha toda a 
estrutura	do	projeto.
43
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Figura	26 – Apresentação da Solution	Explorer
Dentro da Solution	Explorer existem alguns itens como:
•	 AplicacaoTeste:	nome	da	aplicação,	definida	no	momento	da	criação	do	projeto.
•	 Properties	 (propriedades):	propriedades	do	projeto.	Dentro	dela,	podemos	visualizar	 cada	 label 
utilizado	no	projeto	e	configurações	realizadas	para	o	funcionamento	da	aplicação.
•	 References	(referências):	local	onde	se	armazenam	todas	as	referências	utilizadas	na	execução	
da aplicação.
•	 App.config:	 classe	 que	 centraliza	 endereçamentos	 utilizados	 no	 projeto,	 dentro	 deles,	 o	
endereçamento de banco de dados.
•	 Form1:	formulário	inicial	para	desenvolver	o	layout.
•	 Program: classe que define qual formulário será executado primeiro.
Figura	27	–	Nome	da	aplicação	–	AplicacaoTeste
44
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Figura	28 – Properties	(Propriedades)	–	AplicacaoTeste
Figura	29 – References	(Referências)	–	AplicacaoTeste
Figura	30 – App.config	–	AplicacaoTeste
45
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Figura	31 – Classe App.config	–	AplicacaoTeste
Figura	32	–	Form1.cs	–	AplicacaoTeste
Figura	33	–	Form1	–	AplicacaoTeste
46
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Figura	34	–	Program.cs	–	AplicacaoTeste
Figura	35	–	Classe	program.cs	–	AplicacaoTeste
Podemos	 alterar	 algumas	 propriedades	 do	 formulário.	 Na	 camada	 de	 apresentação	 podemos	
adicionar n	projetos,	ou	seja,	não	existe	limitação	de	formulários	dentro	desse	projeto.
Para adicionarmos um novo formulário podemos seguir por esta rota:
47
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
•	 Em	cima	do	projeto	AplicacaoTeste,	devemos	clicar	 com	o	botão	direito.	A	 seguinte	 tela	
será apresentada:
Figura	36	–	Menu	com	itens	a	serem	selecionados
Figura	37	–	Selecionar	o	item	Add  Windows Form
48
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Em seguida acionaremos a rota Add  New	Item, a tela a seguir será apresentada:
Figura	38	–	Tela	para	adicionar	um	novo	item	ao	projeto	–	AplicacaoTeste
Nessa	tela,	podemos	notar	que	é	possível	adicionar	ao	projeto:
•	 classe;
•	 formulário;
•	 classe	de	componente;
•	 diagrama	de	classe.
Figura	39 – Templates	que	podem	ser	adicionados	ao	projeto	–	AplicacaoTeste
49
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Após ser adicionado o novo formulário, a Solution	Explorer	é	atualizada	com	o	novo	item:
Figura	40	–	Form2	adicionado	à	Solution	Explorer
Podemos	alterar	o	nome	do	Form1	para	que	possamos	especificar	melhor	nosso	projeto.
 observação
Dentro da Solution	Explorer	podemos	adicionar	muitos	formulários.	No	
entanto,	 é	muito	 importante	que	 todos	os	 formulários	 sejam	nomeados	
para	 que,	 no	 futuro,	 cada	 um	 possa	 ser	 atribuído	 como	 funcionalidade	
sistêmica	da	aplicação.
Para que essa ação possa ser efetuada, podemos clicar com o botão direito em cima do nome do 
formulário e acionar a ação rename	(renomear).
Figura	41	–	Renomear	Form1	dentro	da	Solution	Explorer
50
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
 observação
Como	 forma	 de	 padronização,	 nomearemos	 as	 interfaces	 iniciando	
sempre com as letras “frm”, representando a abreviação do termo 
“formulário”, de forma que auxilie os desenvolvedores a saberem que tudo o 
que estiver escrito dessa forma deverá ser entendido como implementação 
de interfaces.
Figura	42	–	frmMensagem:	nome	do	novo	formulário
Após ser alterado o nome, acionar o botão enter	 do	 teclado.	 Será	 apresentada	 a	 tela	 a	 seguir,	
perguntando	se	todas	as	classes	poderão	ser	renomeadas;	acionamos	o	botão	“sim”:
Figura	43	–	Confirmação	da	alteração	de	nome	de	Form1	para	frmMensagem
51
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Para	alterarmos	o	nome	da	barra	de	títulos	do	formulário,	deveremos	clicar	com	o	botão	direito	em	
cima	do	formulário	frmMensagem	e	acionar	o	item	properties.
Figura	44 – Properties	(propriedades)	do	formulário	Form1
Será	apresentada,	ao	lado	direito	da	tela,	uma	aba	na	qual	todas	as	propriedades	serão	apresentadas.
Figura	45 – Propriedades do formulário
52
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Todo	formulário	adicionado	contém	suas	respectivas	propriedades.	Dentre	elas,	podemos	alterar:
•	 Nome	do	título.
•	 Cor	de	fundo.
•	 Tamanho	do	formulário.
•	 Fonte.
•	 Controles	do	formulário.
Figura	46 – Propriedade Text	alterada	para	frmMensagem
Quando	a	propriedade	Text	foi	alterada,	automaticamente	o	título	do	formulário	foi	alterado	para	
frmMensagem;	assim,	no	momento	de	execução,	esse	é	o	título	que	será	apresentado.
 Lembrete
Para	efeito	de	padronização,	nomeamos	as	interfaces	iniciando	sempre	
com as letras “frm”, representando a abreviação do termo “formulário”. Isso 
auxilia os desenvolvedores a saberem que tudo o que estiver descrito dessa 
maneira será entendido como implementação de interfaces.
53
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetosii
Figura	47 – Formulário em modo de execução
Podemos, por meio de um protótipo desenvolvido na fase de levantamento de requisitos, iniciar a 
construção	da	camada	de	apresentação.	Um	protótipo	é	uma	visão	de	como	a	camada	de	apresentação	
será	construída	dentro	do	projeto	de	software.
Figura	48 – Protótipo
Com	base	no	protótipo,	podemos	replicar	a	figura	dentro	da	camada	de	apresentação	utilizando	
alguns	componentes‑padrão	do	Microsoft	Visual	Studio.
Os	componentes	que	serão	utilizados	para	a	construção	da	camada	de	apresentação	são:
54
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
•	 Label: responsável por alocar um rótulo na camada de apresentação.
•	 TextBox:	responsável	por	adicionarmos	dados	de	entrada	e	saída	na	camada	de	apresentação.
•	 Button: responsável por executar a ação desenvolvida na linguagem determinada.
Esses componentes estão contidos no ToolBox	(barra	de	ferramentas).
Figura	49 – Componente Label
Figura	50 – Componente TextBox
Figura	51 – Componente Button
 observação
Os	 componentes	 estão	 alocados	 na	 barra	 de	 ferramentas,	 no	 item	
Common Controls.
Iremos iniciar clicando no componente Label	e	arrastando	para	o	formulário.	Todos	os	componentes	
têm	como	premissa	o	comportamento	de	orientação	a	objeto,	ou	seja,	todos	os	componentes	são	objetos	
com as suas respectivas propriedades.
Todo	componente	tem,	em	suas	propriedades,	cor,	tamanho,	posicionamento	etc.
55
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Figura	52	–	Formulário	com	label1
Para	que	o	label1	seja	apresentado	conforme	o	protótipo	anterior	devemos	alterar	a	sua	propriedade	
de nome. Para isso, em cima do label, iremos clicar com o botão direito do mouse, assim sendo apresentado 
um menu.
Figura	53	–	Menu	de	ações	do	label1
Ao	ser	apresentado	esse	menu,	iremos	clicar	em	Propriedades.	Nesse	momento,	para	o	label1,	serão	
visualizadas	todas	as	propriedades	para	esse	componente.
56
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Figura	54	–	Propriedades	do	componente	label1
Podemos	visualizar	diversas	propriedades	atribuídas	ao	componente	label1.	Nesse	primeiro	momento	
iremos alterar as propriedades Name e Text.
Figura	55 – Propriedade Text	do	componente	label1
Nesse	momento,	ao	ser	alterada	a	propriedade	text	do	componente	label1,	automaticamente,	no	
formulário,	é	replicada	e	visualizada	a	alteração.	Após	essa	ação	iremos	alterar	a	propriedade	name do 
componente	label1,	que	será	chamado	de	lblDigiteMensagem.
57
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Figura	56 – Propriedade Name do componente label
Essa	alteração	é	necessária	para	um	bom	entendimento	do	código.	Iremos	acompanhar	mais	à	frente	
que todos os componentes deverão ser nomeados de uma maneira amigável para que possa facilitar o 
desenvolvimento e a manutenção do código.
Quadro 3 – Detalhes de componentes
Componente Name Text 
Label lblDigiteMensagem Digite	uma	Mensagem:
TextBox txtDigiteMensagem N/A
Button btnOk Ok
Podemos perceber que, para cada componente, sempre o seu name irá se iniciar com uma 
identificação	que	remeta	ao	nome	do	componente.	Exemplo:	no	caso	do	nome	lblDigiteMensagem,	as	
letras “lbl” seriam uma espécie de abreviação de label;	já	no	caso	de	btnDigiteMensagem,	as	letras	“btn”	
seriam	a	referência	ao	componente	button.
 observação
Não	 é	 uma	 regra	 trabalhar	 com	 abreviação	 de	 componentes.	 Caso	
o desenvolvedor se sinta confortável, nem precisa alterar o seu name. 
Porém, devemos pensar que podem existir aplicações nas quais, dentro do 
formulário,	podem	existir	dez	TextBox	e,	como	cada	vez	que	é	adicionado	
um	 componente	 o	Microsoft	 Visual	 Studio	 adiciona	 o	 número	 1	 (como	
textbox1,	 textbox2,	 textbox3	 etc.),	 como	 identificar,	 por	 exemplo,	 qual	
textbox equivale ao nome do usuário ou ao login do usuário?
58
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Agora será adicionado o Textbox.	Para	isso,	iremos	localizar	o	componente	na	barra	de	ferramentas	
e arrastar para o nosso formulário.
Figura	57 – Text adicionado ao formulário
Para esse componente, será alterado o seu name. Para essa ação, iremos clicar com o botão direito 
do mouse e será aberto um menu de ações desse componente:
Figura	58	–	Menu	de	ações	do	componente	TextBox
Após esta ação será acionada a propriedade do componente TextBox.	 Serão	 abertas	 todas	 as	
propriedades desse componente:
59
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Figura	59 – Propriedades do componente TextBox
Após	 a	 janela	 de	 propriedades	 ser	 apresentada,	 iremos	 alterar	 a	 sua	 propriedade	 name para 
txtDigiteMensagem.
Figura	60 – Propriedade Name	alterada	para	txtDigiteMensagem
Agora iremos adicionar o nosso terceiro componente no formulário chamado button. Para isso iremos 
até a barra de ferramentas, clicaremos no componente button e vamos arrastá‑lo até o formulário.
60
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Figura	61 – Componente button adicionado ao formulário
Depois, iremos acessar as propriedades do componente button. Para isso, iremos clicar com o botão 
direito em cima do componente button e acionar o item Propriedades.
Figura	62	–	Menu	de	ações	do	componente	button
61
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Figura	63 – Propriedades do componente button
Para esse componente iremos alterar as propriedades name e text, conforme protótipo 
apresentado anteriormente.
Figura	64 – Propriedade name do componente button alterada
62
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Figura	65 – Propriedade text do componente button alterada
Após serem efetuadas todas as inclusões de componentes no formulário, teremos nossa camada de 
apresentação fiel ao protótipo apresentado.
Figura	66 – Camada de apresentação
63
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Para	que	possamos	visualizar	a	nossa	aplicação	devemos	acionar	o	botão	“executar”,	que	fica	no	
menu	superior	do	Microsoft	Visual	Studio.	Nesse	instante	acontecerá	uma	simulação	do	comportamento	
da aplicação, como se ela estivesse instalada, por exemplo, em uma estação de trabalho.
Figura	67	–	Botão	Start, que executa aplicação
Figura	68	–	AplicacaoTeste	sendo	executada
Podemos imprimir a mensagem “Professor” dentro de um label. Para isso seguiremos o escopo a seguir:
•	 Digitar	uma	mensagem	na	caixa	de	texto.
64
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
•	 Acionar	o	botão	Ok.
•	 Apresentar	a	mensagem	por	meio	de	uma	label.
Iremos adicionar uma label logo abaixo da caixa de texto:
Figura	69	–	Label1	inserida	no	formulário
Serão	 alteradas	 as	 propriedades	 Name e Text para identificarmos o componente adicionado 
aoformulário.	 Para	 essa	 ação	 iremos	 clicar	 com	 o	 botão	 direito	 em	 cima	 do	 componente	 label1	 e	
acionaremos o item Properties	(Propriedades).
Figura	70	–	Menu	de	ações	do	componente	label1
65
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Figura	71 – Text	lblMensagem
Figura	72 – Name	lblMensagem
Nesse	momento,	 atendemos	 parcialmente	 o	 requisito	 solicitado.	 Nesse	 instante	 iremos	 iniciar	 a	
codificação.	Para	isso,	acionaremos	o	botão	OK,	efetuando	um	duplo	clique.
66
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Figura	73	–	Modo	de	codificação
Para que possamos entender melhor o cenário proposto, quando o usuário digitar uma mensagem e 
acionar	o	botão	Ok,	a	mensagem	deverá	ser	apresentada	dentro	do	label lblmensagem.
Inicialmente, para que possamos efetuar o entendimento do código, vamos pensar em um 
código estruturado.
Início  Digite uma mensagem  Mensagem é transferida para label	lblMensagem		Fim
Para	que	essa	ação	possa	ser	concretizada	no	código,	digitaremos	a	seguinte	instrução:
Figura	74	–	Código	do	botão	OK
67
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
O	entendimento	do	código	poderia	ser	feito	da	seguinte	maneira:
•	 lblMensagem.Text: neste trecho estamos informando ao código C# o nome do componente 
(lblMensagem)	e	sua	propriedade	(Text).	Quando	a	propriedade	 informada	for	Text, poderemos 
entender	que	ela	irá	receber	dados	alfanuméricos	(String).
•	 txtDigiteMensagem.Text: neste trecho estamos informando ao código C# o nome do 
componente	(txtDigiteMensagem)	e	sua	propriedade	(Text).	Quando	a	propriedade	informada	for	
Text,	poderemos	entender	que	ela	irá	receber	dados	alfanuméricos	(String).
Resumido	a	ação	codificada,	tudo	o	que	estiver	sendo	informado	no	componente	txtDigiteMensagem	
será	enviado	para	o	componente	lblMensagem.
Vamos	executar	nossa	aplicação:
Figura	75	–	AplicacaoTeste	sendo	executada
Após	digitar	a	palavra	“Professor”	na	caixa	de	texto,	acionaremos	o	botão	OK.	Perceba	que	existe	no	
formulário o label	lblMensagem.
68
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Figura	76 – Label recebe palavra digitada na caixa de texto
Nesse	instante,	após	o	botão	Ok	ser	acionando,	o	label	lblMensagem	mudou	para	a	palavra	“Professor”,	
que foi digitada na caixa de texto.
Vamos	exercitar.	A	partir	de	um	protótipo	construído	após	efetuado	um	levantamento	de	requisitos,	
iremos construir uma calculadora, onde teremos as operações básicas da matemática: adição, subtração, 
divisão	e	multiplicação.	Vamos	observar	o	protótipo	construído:
Figura	77 – Protótipo Calculadora
69
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Para	a	efetivação	do	código,	iremos	iniciar	pela	análise	do	protótipo.	Na	figura	podemos	observar	
que existem:
•	 Três	labels.
•	 Quatro	botões.
Quadro 4 – Componentes
Componente Nome Texto 
Label lblDigitePrimeiroNumero Digite	o	primeiro	número
Label lblDigiteSegundoNumero Digite	o	segundo	número
Label lblResultado Resultado
Button btnAdicao +
Button btnSubtracao ‑
Button btnMultiplicação *
Button btnDivisao /
Vamos	programar:
1.	Crie	um	novo	projeto	(Windows	FormApplication),	com	o	nome	de	Calculadora.
2.	Altere	a	propriedade	Text do formulário para Calculadora.
Figura	78	–	Projeto	Windows	Form	Application:	calculadora
70
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
3.	 Agora	 iremos	 inserir	 os	 componentes	 dentro	 do	 formulário,	 conforme	 protótipo	 apresentado	
anteriormente.
Figura	79 – Formulário Calculadora
Podemos	notar	que	todos	os	componentes	inseridos	no	formulário	estão	sem	o	nome;	para	isso,	em	
todos os componentes, iremos alterar as propriedades Name e Text:
Figura	80 – Alterando propriedade Text do botão Adicionar
71
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Figura	81 – Propriedade Name alterada no botão Adicionar
Para todos os componentes de tela iremos alterar as propriedades Name e Text e, para isso, iremos 
para cada componente, clicar com o botão direito e, em seguida, em Properties:
Figura	82 – Properties	(propriedades)	do	botão	Adicionar
Após a execução desse passo, todos os componentes serão alterados e apresentados conforme figura 
a seguir:
72
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Figura	83 – Calculadora com todos os componentes adicionados
Vamos	iniciar	a	codificação	dos	botões	da	nossa	calculadora,	mas,	antes,	precisamos	entender	alguns	
pontos importantes:
•	 Todo	número,	a	princípio,	só	poderá	ser	matematicamente	operado	se	for,	no	mínimo,	do	tipo	inteiro.
•	 Caixas	de	texto	recebem	somente	string.
Para iniciarmos o entendimento de como as operações matemáticas serão efetuadas, precisamos 
entender	 o	 conceito	 de	 Tipos	 Primitivos,	 que	 são	 atribuições	 dadas	 a	 variáveis	 que	 auxiliam	 na	
codificação C#.
Exemplo: precisamos somar dois valores contidos em caixas de texto.
Valor	A:	10.
Valor	B:	10.
Resultado:	20.
Para que essa conta possa ser executada no código C#, podemos inicialmente declarar duas variáveis 
do tipo primitivo inteiro.
73
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Quadro 5 - Tipos primitivos
Tipo Faixa	de	Valores Armazenamento
byte ‑128	a	127 Inteiro	de	8	bits	
short ‑32.768	a	32.767	 Inteiro	de	16	bits
int ‑2.147.483.648	a	2.147.483.647 Inteiro	de	32	bits
long ‑9.223.372.036.854.775.808	a9.223.372.036.854.775.807 Inteiro	de	64	bits
float 1.401298464324811707e‑45	a	3.40282346638528860e+38 Ponto	flutuante	de	32	bits
double 4.94065645841246544e‑324	a	1.79769313486231570e+308 8	bytes	ou	64	bits
char Representam	um	único	caractere 16	bits
boolean True	ou	False 1	bit
Escrevendo	nosso	código,	em	Português	Estruturado,	ficaria:
Inicio
Linha1:	Var	valorA	inteiro;
Linha2:	Var	ValorB	inteiro;
Linha3:	Var	resultado	inteiro;
Linha4:	valorA	=	CaixaTexto(Valor	A)(Inteiro);
Linha5:	valorB	=	CaixaTexto(Valor	B)(Inteiro);
Linha6:	Resultado	=	valorA	+	valorB;
Linha7:	CaixaTexto(resultado)	=	resultado(String);
Fim
 observação
Português	Estruturado	ou	pseudocódigo	é	uma	sequência	de	instruções	
que pode ser entendida por programadores, independentemente da 
linguagem	de	programação	utilizada.
74
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Vamos	entender	a	codificação.
Linhas 1, 2 e 3
Foram	declaradas	as	variáveis	valorA,	valor	e	resultado	do	tipo	inteiro,	ou	seja,	será	por	meio	dessas	
variáveis que serão feitas a atribuição de valores e a execução da operação matemática soma.
Linhas 4, 5 e 6
As	variáveis	valorA	e	valorB	receberam	os	dados	digitados	nas	Caixas	de	Texto	A	e	B,	porém	elas	
deverão	ser	convertidas	para	o	tipo	primitivo	inteiro,	pois	o	seu	conteúdo	é	do	tipo	string.
 observação
Esse item será mais bem‑detalhado quando efetuarmos a codificação 
na linguagemC#.
Linha 6
A	variável	resultado	irá	receber	o	resultado	da	soma	das	variáveis	valorA	e	valorB.
Linha 7
A	Caixa	de	Texto	Resultado	irá	receber	a	variável	resultado,	porém	deverá	ser	feita	uma	conversão	
do tipo inteiro para o tipo string.
Com	o	Português	Estruturado	em	mãos,	vamos	iniciar	a	codificação	utilizando	a	linguagem	C#.	O	
botão	Soma	(+)	será	o	primeiro	a	ser	codificado.	Para	isso	iremos	clicar	duas	vezes	no	botão	(+)	para	que	
possamos ser redirecionados para o módulo de codificação.
75
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Figura	84	–	Modo	codificação
Nesse	 instante	estamos	dentro	da	classe	do	nosso	formulário	Calculadora.	Quando	efetuarmos	o	
duplo	clique	no	botão	(+)	do	formulário,	a	aplicação	irá	nos	direcionar	até	o	evento	do	botão.
Podemos notar que o evento ao qual fomos direcionados, por padrão, é o evento Click,	ou	seja,	no	
momento	em	que	o	formulário	estiver	sendo	executado	e	o	botão	(+)	for	acionado,	será	disparado	o	
evento e executado tudo o que estiver codificado dentro dele.
Para	o	componente	botão	adicionado	no	formulário	existem	inúmeros	eventos.	Para	que	possamos	
visualizar	os	 eventos	do	botão,	 podemos	 clicar	 com	o	botão	direito	do	mouse em cima do botão e 
acionar o item Properties.
76
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Figura	85 – Properties	do	botão	(+)
Logo	abaixo	do	topo	da	janela	Properties,	existe	um	ícone	com	um	símbolo	de	raio,	que	equivale	aos	
eventos	que	podem	ser	atribuídos	ao	botão.
Figura	86	–	Eventos	do	botão	(+)
77
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Na	figura,	podemos	observar	que	o	evento	que	está	acionado	é	o	Click, no qual iremos codificar 
inicialmente.	Existem	diversos	eventos	que	podemos	utilizar	para	a	ação	de	um	botão.
Após estarmos dentro do evento click	do	botão	(+)	iniciaremos	o	desenvolvimento	do	nosso	código.
 Lembrete
Observe	 que	 o	 botão	 (+)	 está	 com	 o	 name	 btnMais,	 ou	 seja,	 para	
qualquer	dúvida,	estamos	programando	dentro	do	evento	click do botão 
(+).	 Esse	 name	 foi	 atribuído	 à	 propriedade,	 facilitando	 o	 trabalho	 de	
codificação	e	de	documentação.	Não	é	uma	regra	trabalhar	com	abreviação	
de	componentes.	No	entanto,	devemos	pensar	que	podem	existir	aplicações	
nas	quais,	dentro	do	formulário,	pode	haver	inúmeros	itens	que	precisem	
ser	organizados	para	auxiliar	o	trabalho	do	desenvolvedor.
A	primeira	etapa	é	declararmos	variáveis	que	receberão	o	conteúdo	digitado	em	tela:
Figura	87 – Declaração de variáveis
Podemos perceber que as variáveis valor1, valor2 e resultado foram declaradas com o tipo primitivo 
int	(inteiro),	ou	seja,	a	soma	somente	irá	aceitar	números	inteiros.	Mais	um	detalhe	é	que	nossas	variáveis	
estão	marcadas	em	verde;	isso	é	uma	ação	que	o	Visual	Studio	realiza	quando	uma	variável	é	declarada,	
porém	não	utilizada	na	estrutura	de	codificação.
78
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
A segunda etapa é receber da calculadora os valores informados em tela:
Figura	88	–	Variáveis	recebendo	valores	informados	na	tela
Nota‑se	 que	 as	 palavras	 txtDigitePrimeiroNumero.Text	 e	 txtDigiteSegundoNumero.Text	 estão	
sublinhadas	em	vermelho;	vamos	entender:
•	 Estamos	 enviando	 um	 conteúdo	 string para uma variável que foi declarada como tipo 
primitivo inteiro.
•	 Precisamos	atribuir	o	contexto	string	à	variável	inteiro	para	que	o	cálculo	possa	ser	realizado.
Para isso precisamos converter (transformar) o tipo primitivo string, que está na propriedade text, 
para	o	tipo	primitivo	inteiro.	Com	esse	objetivo	iremos	escrever	a	seguinte	linha:
79
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Figura	89	–	Convertendo	tipo	primitivo	(String	para	Inteiro)
Iremos	utilizar	Convert.ToInt16	para	que	possamos	pegar	o	conteúdo	informado	dentro	do	componente	
text para o tipo primitivo inteiro, assim iremos conseguir efetuar, inicialmente, a soma de valores.
Após essa ação nosso código prosseguirá da seguinte maneira:
Figura	90	–	Variável	resultado	recebendo	o	valor	da	soma
80
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Após definido o código, precisamos informar o resultado dentro do componente text e, para isso, 
iremos	 efetuar	 o	processo	 inverso	de	 transformação	de	 tipo	primitivo,	 ou	 seja,	 nosso	 código	 terá	o	
seguinte comportamento:
Figura	91 – Componente Text recebendo o valor da variável resultado
Podemos perceber que, para o componente text	(txtResultado.Text),	a	variável	foi	transformada	do	
tipo primitivo inteiro para o tipo primitivo string,	assim	podendo	ser	visualizada	dentro	do	componente	
text	no	momento	de	sua	execução.	Agora	iremos	executar	a	nossa	aplicação	acionando	a	tecla	F5.
Figura	92 – Aplicação em modo de execução
81
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Nesse	momento,	nossa	aplicação	está	rodando	e	 iremos	 informar	dois	valores	para	efetuarmos	a	
nossa soma:
Figura	93	–	Valores	sendo	informados	na	caixa	de	texto
Após	informarmos	os	valores	iremos	acionar	o	botão	(+)	da	tela.	Nesse	instante	nosso	código	será	
executado, e o valor da soma será apresentado na caixa de texto Resultado:
Figura	94	–	Valor	da	soma	apresentado	na	caixa	de	texto
82
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Para as operações de subtração e multiplicação o comportamento do código será muito semelhante 
à	ação	de	soma.
Para	a	ação	de	multiplicação,	iremos	clicar	duas	vezes	no	botão	(*)	e	programar	o	seguinte	código:
Figura	95 – Código que efetua a multiplicação de valores
Figura	96	–	Valor	da	multiplicação	apresentado	na	caixa	de	texto	Resultado
83
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Figura	97 – Código que efetua a subtração de valores
Figura	98	–	Valor	da	subtração	apresentada	na	caixa	de	texto	Resultado
Nesse	instante	será	efetuado	o	teste	para	divisão.	No	entanto,	neste	caso,	precisamos	tomar	alguns	
cuidados	específicos.	Dentre	eles,	considerar	a	questão:	todo	número	é	divisível	por	zero	(0)?
 Saiba mais
Leia	o	artigo	de	Gabriel	Alessandro	de	Oliveira,	para	entender	um	pouco	
mais	sobre	o	tema.	Ele	está	disponível	no	seguinte	endereço:
84
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
UNIVERSIDADE	FEDERAL	DO	RIO	GRANDE	DO	SUL	(UFRGS).	Calculando 
com	o	zero:	dividindo	por	zero.	Porto	Alegre:	UFRGS,	 [s.d.].	Disponível	em:	
<http://www.mat.ufrgs.br/~portosil/passa7d.html>.	Acesso	em:	22	jun.	2015.
Vamos	rodar	nossa	solução	para	verificar	o	comportamento	do	nosso	código:
Figura	99	–	Divisão	não	pode	ser	realizada
Ao	ser	realizada	a	divisão	10/0	surge	uma	mensagem	no	código	informando	que	a	divisão	por	zero	
não	pode	ser	realizada,	mas	como	podemos	tratar	esse	erro?
4.3 desvios condicionais
4.3.1 Desvios condicionais (Comandos de Seleção)
Além dos algoritmos sequenciais, também denominados lineares, há problemase situações que 
necessitam	da	introdução	de	comandos	de	seleção	(desvios	condicionais	simples	e	desvios	condicionais	
compostos)	para	que	as	decisões	possam	ser	tomadas.	No	caso	da	aplicação	que	estamos	desenvolvendo,	
precisamos	criar	um	“desvio”	para	a	condição	de	divisão	por	zero	(0).
4.3.2 Condição
Chamamos	de	condição	a	expressão	lógica	que	norteia	a	tomada	de	certa	decisão,	ou	seja,	precisamos	
definir	uma	expressão	que	direcione	a	solução	do	item	divisão	por	zero	(0).
85
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Por	exemplo:	imagine	que,	após	a	realização	do	exame	final,	a	média	mínima	para	que	um	aluno	seja	
aprovado	em	determinada	disciplina	seja	igual	a	5.	Se	chamarmos	de	M	a	variável	que	indica	a	média	
do	aluno,	teremos	que	a	condição	para	que	o	estudante	seja	aprovado	é	M>=5.	Em	outras	palavras,	a	
expressão	lógica	que	norteia	a	tomada	de	decisão	(ser	aprovado	ou	ser	reprovado)	é	M	>=	5.
Para o cenário que existe em nosso exemplo da calculadora podemos iniciar a expressão considerando 
que	o	valor2	deverá	ser	maior	que	zero	(0):	valor2	>	0.
4.3.3 Decisão
A decisão é tomada em função de uma condição ser ou não satisfeita. Assim, a tomada de decisão 
implica a escolha de qual trecho do algoritmo deve ser executado de acordo com o resultado obtido e 
com a sua comparação a uma condição estabelecida.
A	condição	que	oferece	o	critério	de	decisão	é	satisfeita	ou	não,	ou	seja,	admitem‑se	apenas	duas	
respostas	possíveis.	Assim,	a	decisão	envolverá,	no	máximo,	duas	opções:	uma	ação	no	caso	de	a	condição	
ser	verdadeira	(V)	e	outra	no	caso	de	a	condição	ser	falsa	(F).	Nessas	situações,	temos	o	chamado	desvio	
condicional composto.
Há	casos	que	apresentam	somente	a	primeira	alternativa:	neles,	se	a	condição	for	falsa	(F),	o	algoritmo	
continuará	o	fluxo	de	instruções	posteriores	ao	desvio	condicional.	Nessas	situações,	temos	o	chamado	
desvio condicional simples.
Em	vez	de	usarmos	as	notações	de	condição	verdadeira,	indicada	por	(V),	e	de	condição	falsa,	indicada	
por	(F),	podemos	utilizar,	respectivamente,	“sim”	(S)	e	“não”	(N).
4.3.4 Desvio condicional simples
O	desvio	condicional	simples	é	uma	estrutura	utilizada	em	algoritmos	e	programas	computacionais	
na	qual	se	indica	uma	tomada	de	decisão,	ou	seja,	um	algoritmo	é	executado	caso	determinada	condição	
seja	verdadeira	(V).
A seguir apresentamos a sintaxe do desvio condicional simples para programas elaborados em 
Português	Estruturado.
 Lembrete
Português	Estruturado	ou	pseudocódigo	é	uma	sequência	de	instruções	
que pode ser entendida por programadores, independentemente da 
linguagem	de	programação	utilizada.
86
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
Se	(CONDIÇÃO) então
<instruções	a	serem	executadas	no	caso	de	a	condição	ser	verdadeira>;
Fim_se;
Genericamente, o fluxograma relacionado ao desvio condicional simples é o mostrado na figura a seguir.
 observação
Fluxograma é uma representação gráfica de um procedimento, 
problema	ou	sistema	cujas	etapas	ou	módulos	 são	 ilustrados	de	 forma	
encadeada	 por	 meio	 de	 símbolos	 geométricos	 interconectados	 para	 a	
representação de um algoritmo.
Figura	100 – Exemplo de desvio condicional simples
4.3.5 Desvio condicional composto
O	 desvio	 condicional	 composto	 é	 uma	 estrutura	 utilizada	 em	 algoritmos	 e	 programas	
computacionais.	Nela,	 indica‑se	uma	tomada	de	decisão	de	executar	um	trecho	do	algoritmo	caso	
determinada	condição	seja	verdadeira	 (V)	e	outra	 tomada	de	decisão	de	executar	outro	 trecho	do	
algoritmo	caso	essa	condição	seja	falsa	(F).
A seguir, apresenta‑se a sintaxe do desvio condicional composto para programas elaborados em 
Português	Estruturado.
87
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Se	(CONDIÇÃO) então
<instruções	a	serem	executadas	no	caso	de	a	condição	ser	verdadeira>;
Senão
<instruções	a	serem	executadas	no	caso	de	a	condição	ser	falsa>;
Fim_se;
Genericamente, o fluxograma relacionado ao desvio condicional composto é o mostrado na figura 
a seguir:
Figura	101 – Exemplo de desvio condicional composto
4.3.6 Operadores Lógicos
O	uso	combinado	dos	diversos	tipos	de	operadores	proporciona	a	execução	das	tarefas	mais	comuns	
de processamento de dados.
Quadro 6 – Operadores lógicos
OPERADOR OPERAÇÃO
E	(AND) COJUNÇÃO	LÓGICA
OU	(OR) DISJUNÇÃO	LÓGICA
NÃO	(NOT) NEGAÇÃO
88
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
A prioridade dos operadores lógicos é a seguinte:
•	 Prioridade	mais	alta:	NOT.
•	 Prioridade	média:	AND.
•	 Prioridade	mais	baixa:	OR.
Para	iniciarmos	a	resolução	do	problema	de	divisão	por	zero	(0),	iremos	pensar	na	seguinte	estrutura:
•	 Criar	uma	condicional	simples	para	que	possamos	tratar	dessa	situação,	conforme	ilustra	a	figura.
Figura	102 – Código C# com condicional simples
Para entendermos melhor o código apresentado vamos seguir com a análise:
•	 A	variável	valor2	recebe	o	conteúdo	da	caixa	de	texto	txtDigiteSegundoNumero.
•	 Após	a	variável	valor2	estar	carregada,	é	feita	a	seguinte	validação:	se	valor2	for	diferente	(!=)	de	
zero	(0),	então	efetue	o	cálculo	e	apresente	o	valor	na	caixa	de	texto	txtResultado.
Efetuando o teste, iremos obter o seguinte cenário:
89
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Figura	103 – Cenário de sucesso
Figura	104 – Cenário de falha
Podemos perceber que o cálculo não foi efetuado, porém nenhuma mensagem foi informada para 
o usuário que está interagindo com o sistema. Para isso teremos de aplicar como solução a condicional 
composta.
Vamos	efetuar	uma	análise:
•	 Se	o	valor2	recebido	pela	caixa	de	texto	txtDigiteSegundoNumero	for	diferente	(!=)	de	zero	(0),	
então deverá ser feito o cálculo e apresentado o resultado na caixa de texto txtResultado.
90
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Unidade II
•	 Senão,	ou	seja,	se	valor2	recebido	pela	caixa	de	texto	txtDigiteSegundoNumero	for	igual	(==)	a	
zero	(0),	então	deverá	ser	exibida	uma	mensagem	para	o	usuário	informando	que	não	existe	a	
possibilidade	de	efetuar	o	cálculo	desejado.
Como	essa	ação	deverá	ser	codificada?	Vamos	analisar	a	figura	a	seguir:
Figura	105 – Código C# com condicional composta
Vamos	executar	o	código	para	entendermos	melhor:
Figura	106 – Apresentação do cenário com falha
91
Re
vi
sã
o:
 R
os
e 
C.
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
3/
06
/1
5
Programação orientada a objetos ii
Para que possamos entender o código criado, colocamos a condicional composta da seguinte maneira:
•	 Se	a	condição	for	atendida,	o	cálculo	será	realizado,	senão	será	exibida	uma	mensagem,	utilizando	
o método messagebox.show.
 Saiba mais
Leia	a	definição	do	método	MessageBox.Show	para	entender	um	pouco	
mais sobre o tema:
MÉTODO	 MessageBox.Show.	 Microsoft	 Developer	 Network.	 2015.	
Disponível	em:	<https://msdn.microsoft.com/pt‑br/library/system.windows.
forms.messagebox.show%28v=vs.110%29.aspx>.	Acesso	em:	10	jun.	2015.
 resumo
Abordamos os principais conceitos da disciplina de Programação 
Orientada	 a	 Objetos	 II,	 utilizando	 como	 conceito	 a	 linguagem	 de	
programação C#. Entendemos que a construção de uma classe e todo o 
seu	processo	de	 transformaçãoem	cada	objeto	 tem	por	finalidade	 criar	
mecanismos que possam interagir entre aplicação e usuário.
Também	 foram	 abordados	 conceitos	 de	 atributos	 de	 classes,	 que,	
por	 sua	 vez,	 são	 características	 de	 uma	 classe	 que	 tem	 como	 premissa	
a	 interação	 com	 métodos	 construídos.	 Também	 foram	 apresentadas	
técnicas de desenvolvimento na linguagem C#, bem como a apresentação 
da	 IDE	Microsoft	 Visual	 Studio,	 seus	 recursos	 e	 conceitos	 iniciais	 para	o	
desenvolvimento	de	aplicação	utilizando	o	template Windows Form.
Conhecemos também desvios condicionais que irão possibilitar tomadas 
de decisões desenvolvidas na linguagem C# e seus operadores lógicos, que 
serão	 capazes	 de	 auxiliar	 o	 desenvolvimento	 de	 aplicações,	 bem	 como,	
ao final de sua codificação, apresentar, por exemplo, uma mensagem de 
retorno do desvio codificado.
Encerramos	 vendo	 a	 importância	 do	 entendimento	 do	 português	
estruturado, que será uma derivação para o código na linguagem C#, bem 
como	a	segregação	de	código,	utilizando	como	recurso	de	aprendizado	o	
MVC	(Model, View, Controller).