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

Prévia do material em texto

92
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 III
Unidade III
Apresentamos o desenvolvimento estruturado em multicamadas, ou seja, segregar todo o código 
em camadas como: interface, persistência e dados. Assim, são de grande importância o conhecimento 
e a apresentação desse modelo, que ganha força no cenário mundial de desenvolvimento de software.
5 EfEtuando incrEmEntos na solução
Podemos efetuar diversos tratamentos no código C# para melhorarmos a performance, eficácia e 
eficiência da solução. Utilizando a nossa calculadora como exemplo, podemos incluir um botão Sair em 
nossa aplicação. Iremos adicionar um botão no formulário com as seguintes características:
•	 Caixa	de	Ferramentas	(ToolBox):	adicionar	componente	button.
•	 Alterar	a	propriedade	name de button1 para btnSair.
•	 Alterar	a	propriedade	text de button1 para Sair.
Figura	107	–	Aplicação	do	botão	Sair	no	modo	Formulário
Vamos codificar o botão. Para isso iremos clicar duas vezes no botão Sair no modo Design para 
sermos direcionados para o evento desse botão.
93
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	108 – Evento click do botão Sair
Para	efetuar	o	código	iremos	utilizar	o	método	nativo	Close(),	que	ao	ser	acionado	irá	encerrar	a	aplicação.
 saiba mais
Leia	mais	 sobre	a	definição	do	Método	Close()	para	entender	melhor	
sobre o tema:
MÉTODO	Form.Close.	Microsoft Developer Network.	2015.	Disponível	em:	
<https://msdn.microsoft.com/pt‑br/library/system.windows.forms.form. 
close(v=vs.110).aspx>.	Acesso	em:	11	jun.	2015.
Figura	109	–	Método	Close()	inserido	no	evento	click btnSair
94
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 III
Vamos executar a aplicação:
Figura	110 – Aplicação em modo de execução com o botão Sair
Ao acionar o botão Sair, será direcionado para o modo de codificação no Microsoft Visual Studio:
Figura	111	–	Tela	apresentada	após	aplicação	ser	encerrada
Podemos também incluir um botão Limpar, que será acionado logo após o cálculo ser efetuado, ou seja, 
ao acioná‑lo, todas as caixas de texto serão inicializadas. Para isso, deve‑se proceder da seguinte maneira:
•	 Adicionar	botão	Limpar:	barra	de	ferramentas	(ToolBox),	adicionar	componente	button.
•	 Para	o	componente	button: alterar a propriedade name de button1 para btnLimpar.
95
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	o	componente	button: alterar a propriedade text de button1 para Limpar.
Figura	112	–	Botão	Limpar	incluído	no	modo	Design
Para o evento click do botão Limpar será implementado o seguinte código:
Figura	113 – Código para o evento click Limpar
Vamos entender o código:
•	 Para	os	componentes	txtDigitePrimeiroNumero,	txtDigiteSegundoNumero	e	txtResultado	foram	
atribuídos o conteúdo vazio, ou seja, string.Empty.
96
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 III
•	 Após	essa	ação,	o	cursor	será	“setado”	para	o	componente	txtDigitePrimeiroNumero	por	meio	do	
método	nativo	Focus().
Executando a aplicação teremos o seguinte comportamento:
Figura	114 – Ação do botão Soma
Figura	115 – Acionado o botão Limpar
O	 componente	 Resultado	 pode	 ser	 eliminado	 do	 formulário,	 e	 o	 resultado	 do	 cálculo	 pode	 ser	
apresentado	dentro	da	caixa	de	texto.	Para	isso	iremos	comentar	(utilizando	“//”)	o	trecho	de	código	
selecionado e efetuar o seguinte ajuste:
97
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	116 – Código que possibilita apresentar valor na caixa de mensagem
Executando a aplicação, temos a seguinte visualização:
Figura	117	–	Resultado	da	divisão	apresentado	na	caixa	de	mensagem
98
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 III
O	mesmo	código	será	replicado	para	as	operações	multiplicação,	adição	e	subtração:
Figura	118 – Código que possibilita apresentar valor na caixa de mensagem
Figura	119	–	Resultado	da	multiplicação	apresentado	na	caixa	de	mensagem
99
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	120 – Código que possibilita apresentar valor na caixa de mensagem
Figura	121	–	Resultado	da	subtração	apresentado	na	caixa	de	mensagem
100
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 III
Figura	122 – Código que possibilita apresentar valor na caixa de mensagem
Figura	123	–	Resultado	da	soma	apresentado	na	caixa	de	mensagem
Para	o	botão	Sair	podemos	implementar	uma	regra	de	“permanência	na	tela”.	No	cenário	atual,	quando	
o botão Sair é acionado, a aplicação é encerrada. A implementação sugerida será um questionamento 
para o usuário que está interagindo com a aplicação, se ele deseja sair ou não dela. Para isso o seguinte 
código deverá ser implementado no evento click do botão Sair:
101
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	124 – Implementação da nova caixa de mensagem
Vamos entender o código:
•	 Dentro	do	método	nativo	MessageBox.Show	serão	definidos:	mensagem	que	será	apresentada	
na	caixa	de	mensagem,	título	da	caixa	de	mensagem,	botões	que	serão	apresentados	na	caixa	de	
mensagem	(Yes/No	–	Sim/Não)	e	ícone	que	será	apresentado	na	caixa	de	mensagem.
•	 O	 retorno	do	clique	nos	botões	Yes/No	será	atribuído	à	variável	 result,	 em	que	ela	 receberá	o	
clique	do	botão	No	(por	meio	da	classe	DialogResult).
Figura	125 – Caixa de mensagem
102
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 III
•	 Se	o	botão	Sim	for	acionado,	deverá	ser	processado	o	Método	Close()	para	efetuar	o	encerramento	
da aplicação.
•	 Se	o	botão	Não	for	acionado,	deverá	permanecer	na	aplicação.
Para	a	caixa	de	texto	Resultado	podemos	pensar	em	mais	um	tratamento	de	melhoria.	No	cenário	
atual,	podemos	efetuar	o	cálculo,	porém,	a	caixa	de	texto	Resultado	fica	“editável”,	ou	seja,	podemos	
manipular o valor a qualquer momento.
Figura	126 – Valor da soma totalmente errado após manipulação
Para	que	uma	“trava”	possa	ser	colocada	na	caixa	de	texto,	podemos	adotar	a	propriedade	Enabled 
(Ativar/Desativar)	na	propriedade	text.
 saiba mais
Leia sobre a propriedade Control.Enabled para entender um pouco mais 
sobre o tema:
PROPRIEDADE	 Control.Enabled.	 Microsoft Developer Network.	 2015.	
Disponível em: <https://msdn.microsoft.com/pt‑br/library/system.windows.
forms.control.enabled%28v=vs.110%29.aspx>.	Acesso	em:	12	jun.	2015.
103
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
Vamos entender melhor como alterar essa propriedade:
Figura	127 – Propriedade Enabled	da	caixa	de	texto	Resultado
Podemos perceber que a propriedade Enabled	é	do	tipo	booleana	(true/false	–	verdadeiro/falso)	e,	
para	deixar	“bloqueada”	a	caixa	de	texto	Resultado,	será	“setada”	a	propriedade	Enabledpara false.
Figura	128 – Propriedade Enabled	“setada”	para	false
104
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 III
Vamos executar nossa aplicação:
Figura	129 – Caixa de texto resultado com a propriedade enabled false
Podemos	notar	que	a	caixa	de	texto	Resultado	fica	com	a	cor	cinza	e	desabilitada,	possibilitando	a	
carga da caixa e impossibilitando a edição dela.
Figura	130	–	Operação	de	soma	apresentando	Resultado	na	caixa	de	texto	bloqueada
105
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	131	–	Operação	de	subtração	apresentando	Resultado	na	caixa	de	texto	bloqueada
Figura	132	–	Operação	de	divisão	apresentando	Resultado	na	caixa	de	texto	bloqueada
106
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 III
Figura	133	–	Operação	de	multiplicação	apresentando	Resultado	na	caixa	de	texto	bloqueada
Podemos,	em	vez	de	colocar	uma	“trava”	na	caixa	de	texto,	ocultá‑la	e	somente	apresentar	a	caixa	
quando	os	botões	de	soma,	multiplicação,	divisão	ou	subtração	forem	acionados.	Para	isso	iremos	utilizar	
a propriedade Visible, que possibilita ocultar os componentes selecionados. Essa propriedade trabalha da 
mesma maneira que a propriedade Enabled,	ou	seja,	com	tipo	booleano	(true/false	–	verdadeiro/falso).
 saiba mais
Leia a seguinte página para entender um pouco mais sobre a propriedade 
Control.Visible.
PROPRIEDADE	 Control.Visible.	 Microsoft Developer Network.	 2015.	
Disponível em: <https://msdn.microsoft.com/pt‑br/library/system.windows.
forms.control.visible%28v=vs.110%29.aspx>.	Acesso	em:	12	jun.	2015.
107
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
Efetuando essa implementação, teremos:
Figura	134 – Alterando propriedade Visible da caixa de texto resultado
Para essa implementação deveremos também efetuar a alteração da propriedade Visible no 
componente label resultado:
Figura	135 – Alterando propriedade visible do componente label resultado
108
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 III
,Após essa alteração vamos executar nossa aplicação:
Figura	136 – Execução da aplicação sem os componentes label e texbox resultado
Percebe‑se	que	os	componentes	 lblResultado	e	txtResultado	não	foram	apresentados,	mas	como	
será apresentado o resultado da ação matemática?
Para isso teremos de efetuar a seguinte implementação:
Figura	137 – Implementação no evento click btnSoma
Quando o botão Soma for acionado, a propriedade Visible	 dos	 componentes	 lblResultado	 e	
txtResultado	será	alterada	para	true	(verdadeiro),	possibilitando	a	visualização	do	resultado	do	cálculo.
109
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	138 – Comportamento inicial da aplicação
Figura	139	–	Resultado	do	cálculo	apresentado	para	o	usuário
110
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 III
No entanto, necessitamos efetuar mais uma implementação:
Figura	140 – Implementação no evento click Limpar
Quando	o	botão	“Limpar”	for	acionado,	a	aplicação	deverá	voltar	para	o	seu	estado	de	origem,	ou	
seja,	aplicação	sem	os	componentes	lblResultado	e	txtResultado	visíveis	para	o	usuário.
Figura	141 – Soma apresentada para o usuário
111
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	142	–	Botão	Limpar	acionado	e	aplicação	retornando	ao	estado	inicial
Para	uma	melhor	disposição	das	informações	no	formulário,	iremos	adicionar	mais	um	componente,	
chamado groupBox,	que	possibilita	uma	melhor	apresentação	das	informações	dentro	do	formulário.	
Esse componente encontra‑se em ToolBox  Containers  GroupBox.
Figura	143 – Componente GroupBox
112
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 III
Figura	144 – GroupBox adicionado no modo design do formulário
Após ser adicionado o formulário devemos alterar as seguintes propriedades:
•	 Name: grpEntradaValores.
•	 Text: Entrada de Valores
Para essa ação iremos clicar com o botão direito no componente groupBox e selecionar o item Properties.
Figura	145 – Alterando propriedades Name e Text do componente groupBox
113
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 essa ação iremos selecionar os seguintes componentes segurando a tecla Ctrl do teclado e 
clicando nos componentes:
•	 lblDigitePrimeiroNumero.
•	 txtDigiteSegundoNumero.
•	 lblDigiteSegundoNumero.
•	 txtDigiteSegundoNumero.
Figura	146 – Componentes selecionados
Após a seleção efetuada iremos utilizar a combinação de teclas Ctrl + X, que irá possibilitar o recorte 
dos componentes:
Figura	147	–	Formulário	com	os	componentes	selecionados	recortados
114
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 III
Em seguida selecionaremos o groupBox Entrada de Valores e iremos efetuar, dentro dele, a combinação 
de teclas Ctrl + V, que efetuará a inclusão dos componentes dentro do groupBox.
Figura	148 – Componentes inseridos no groupBox Entrada de Valores
Ao clicarmos no groupBox Entrada de Valores, podemos alocar os componentes nele contidos em 
qualquer lugar dentro do formulário.
Figura	149 – GroupBox	Entrada	de	Valores	alocado	à	esquerda	do	formulário
115
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
Podemos aplicar o groupBox para os demais itens do formulário:
Figura	150 – Incluindo groupBox	Operações	Matemáticas
Figura	151 – GroupBox	Operações	Matemáticas	com	os	componentes	soma,	subtração,	divisão	e	multiplicação
116
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 III
Figura	152 – GroupBox	Resultado	com	o	componente	Resultado
Executando a aplicação teremos a seguinte visualização:
Figura	153 – Layout reformulado da aplicação
 saiba mais
Acesse a seguinte página para entender um pouco mais sobre a classe 
GroupBox:
CLASSE	GroupBox.	Microsoft Developer Network.	2015.	Disponível	em:	
<https://msdn.microsoft.com/pt‑br/library/system.windows.forms.group 
box%28v=vs.110%29.aspx>.	Acesso	em:	12	jun.	2015.
117
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
Podemos também otimizar o layout com os seguintes itens:
•	 Travar	formulário	para	redimensionamento.
•	 Ocultar	componentes	do	formulário	(Minimizar,	Maximizar	e	Fechar).
Para inibir o redimensionamento do formulário será alterada a propriedade AutoSizeMode para 
GrowAndShrink, que impossibilita a ação do usuário para o redimensionamento.
Figura	154 – Propriedade AutoSizeMode
 saiba mais
Para	entender	um	pouco	mais	sobre	a	propriedade	Form.AutoSizeMode,	leia:
PROPRIEDADE	 Form.AutoSizeMode.Microsoft Developer Network. 
2015.	 Disponível	 em:	 <https://msdn.microsoft.com/pt‑br/library/system.
windows.forms.form.autosizemode%28v=vs.110%29.aspx>.	 Acesso	 em:	
12	jun.	2015.
118
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 III
Executando a aplicação podemos notar:
Figura	155	–	Aplicação	“travada”	para	redimensionamento
Podemos encostar o cursor do mouse em volta do formulário, mas não é possível efetuar o 
redimensionamento, ou seja, a apresentação do formulário em modo de execução será mantida.
Outra	 alteração	 a	 ser	 efetuada	 é	 ocultar	 os	 itens	Minimizar,	Maximizar	 e	 Fechar.	 Para	 isso	 será	
alterada a propriedade ControlBox.	Essa	propriedade,	como	algumas	já	vistas	neste	livro‑texto	(Enabled 
e Visible),	trabalha	com	o	tipo	booleno	(true/false	–	verdadeiro/falso).
Figura	156 – Propriedade ControlBox
119
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
Ao alterar a propriedade de ControlBox para false teremos a seguinte visualização:
Figura	157 – Modo design atualizado
Podemos	notar	que	os	botões	Minimizar,	Maximizar	e	Fechar	foram	retirados	do	formulário.
Figura	158 – Aplicação em modo de execução
 lembrete
Para que possamos visualizar a aplicação, devemos acionar o botão 
Executar, no menu superior do Microsoft Visual Studio, que apresentará uma 
simulação do comportamento da aplicação como se ela estivesse instalada.
6 dEsEnvolvimEnto dE aplicação Em camadas
6.1 camada modelo
A camada Modelo é responsável por efetuar um espelhamento das tabelas que são construídas no 
banco	de	dados.	Por	facilitar	o	tráfego	de	informações	pelas	camadas,	ela	é	de	extrema	importância	para	
a execução. Incluindo um novo projeto, vamos obter a seguinte visualização:
120
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 III
Figura	159	–	Adicionado	projeto	Modelo	(Cadastro_Aluno_Modelo)
 lembrete
Para efetuarmos a inclusão de um novo projeto dentro da solução, basta 
clicar com o botão direito no nome da solução e acionar o item AddNew 
ProjectVisual C# Windows  Class Library
A classe será renomeada para mdlAluno:
Figura	160 – Classe mdlAluno
121
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
É muito importante o conhecimento de criação de tabelas, procedures, 
relacionamentos, chaves e query, pois com esse conhecimento a codificação 
com acesso a banco de dados se torna mais fácil e amigável.
Figura	161	–	Tabela	Aluno
 observação
Toda	a	construção	de	tabelas	será	feita	utilizando	o	Microsoft	Access	
2007.	Utilizando	esse	banco	será	possível	efetuar	a	conexão	com	banco	de	
dados de maneira fácil e amigável.
Após	a	construção	da	tabela	Aluno	(tblAluno),	a	classe	mdlAluno	terá	o	seguinte	código:
122
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 III
Figura	162 – Classe mdlAluno com atributos da tabela tblAluno
Podemos perceber que todos os atributos contidos na tabela tblAluno estão inseridos na classe 
mdlAluno; para que possamos entender melhor, iniciaremos a codificação do evento click Inserir:
Figura	163 – Evento click botão Inserir
Para iniciarmos a codificação deste item, vamos precisar definir alguns passos:
•	 Efetuar	a	referência	do	projeto	Cadastro_Aluno_Modelo	no	projeto	CadastroAluno.
123
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
•	 Codificar	a	biblioteca	de	referência	do	projeto	Cadastro_Aluno_Model	no	projeto	CadastroAluno.
Figura	164 – Adicionar referência no projeto CadastroAluno
Figura	165	–	Adicionada	referência	Cadastro_Aluno_Modelo
Após efetuados os passos, iremos codificar a biblioteca dento da classe frmCadastroAluno.cs:
124
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 III
Figura	166	–	Inclusão	da	biblioteca	Cadastro_Aluno_Modelo
Todas	as	propriedades	contidas	na	classe	mdlAluno	ficaram	visíveis	no	modo	de	codificação.	Para	
que o código se torne visível, deverá ser criada uma instância de objeto.
 saiba mais
Para entender melhor sobre a criação de instâncias, indicamos a leitura 
do seguinte artigo:
CONSTRUTORES	de	instâncias	(Guia	de	Programação	em	C#).	Microsoft 
Developer Network.	 2015.	 Disponível	 em:	 <https://msdn.microsoft.com/
pt‑br/library/k6sa6h87.aspx>.	Acesso	em:	12	jun.	2015.
Figura	167	–	Objeto	_mdlAluno	instanciado
125
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
Com	o	objeto	_mdlAluno	instanciado,	todos	os	atributos	poderão	ser	visualizados	dentro	do	evento,	
assim efetuando a herança de todos os atributos.
 saiba mais
Leia o seguinte texto sobre herança na linguagem C# para entender um 
pouco mais sobre o tema:
HERANÇA	(Guia	de	programação	em	C#).	Microsoft Developer Network. 
2015.	Disponível	em:	<https://msdn.microsoft.com/pt‑br/library/ms173149.
aspx>.	Acesso	em:	15	jun.	2015.
Figura	168 – Atributos visíveis no evento click btnIncluir
Agora será criado o projeto Controle, responsável por receber os parâmetros do projeto view 
(CadastroAluno)	e	efetuar	as	devidas	ações	no	banco	de	dados	por	meio	de	métodos	inseridos	na	classe.
126
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 III
Figura	169	–	Projeto	Cadastro_Aluno_Controle
Vamos precisar incluir o projeto CadastroAluno efetuando os seguintes passos:
•	 Incluir	o	projeto	Cadastro_Aluno_Modelo	na	pasta	de	referência	do	projeto	Cadastro_Aluno_Controle.
•	 Codificar	a	biblioteca	Cadastro_Aluno_Modelo	na	classe	ctlAluno.
Figura	170	–	Acessando	a	pasta	de	referência	do	projeto	Cadastro_Aluno_Controle
127
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	171	–	Adicionando	a	referência	Cadastro_Aluno_Modelo	no	projeto	Cadastro_Aluno_Controle
Figura	172		–	Biblioteca	Cadastro_Aluno_Modelo	referenciada	na	classe	ctlAluno
Após	 esse	 passo	 devemos	 também	 efetuar	 a	 referência	 do	 projeto	 Cadastro_Aluno_Controle	 no	
CadastroAluno, para que possamos acessar todos os métodos contidos na classe ctlAluno.
128
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 III
Figura	173 – Pasta de referência do projeto CadastroAluno
Figura	174	–	Adicionando	referência	do	projeto	Cadastro_Aluno_Controle
 observação
Lembrando que todas as referências foram criadas com o intuito de 
garantir o entendimento do exemplo exposto. Porém é muito importante 
que possamos seguir um padrão de nomenclatura de referência para 
garantir o entendimento e a facilidade em sua manutenção.
129
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	175	–	Declarando	referência	Cadastro_Aluno_Controle
Após esse passo será apresentado todo o fluxo de codificação para a inclusão do registro do aluno 
na base de dados.
Figura	176	–	Objeto	_ctlAluno	instanciado
6.1.1Método Cadastrar
Cada método trabalha de maneira independente, sendo utilizado quando solicitado. Com o aporte 
da análise e conceitos definidos de método, identificou‑se a necessidade de se criar o Método Cadastrar. 
130
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 III
Esse método será responsável por capturar os valores informados na tela e inseridos na base de dados, 
conforme código a seguir:
Método cadastrar contido dentro da classe ctlAluno
public bool Cadastrar(string nome, string rg, string cpf)
 {
 string query = “INSERT into tblAluno(nome, rg, cpf) VALUES (‘” + 
nome + “’, ‘“ + rg + “’, ‘“ + cpf + “’ )”;
 OleDbDataReader reader = null;
 OleDbConnection conn = null;
 try
 {
 conn = obterConexao();
 //
 // Criação do objeto comando, que recebe a query que será uti-
lizada na operação e a conexão com o banco.
 //
 OleDbCommand cmd = new OleDbCommand(query, conn);
 //
 // Executa comando
 //
 
 reader = cmd.ExecuteReader();
 //
 //interage com a tabela retornada
 //
 while (reader.Read())
 {
 return true;
 }
 fecharConexao(conn);
 }
 catch (Exception ex)
 {
 throw ex;
 }
 finally
 {
 //
 // Garante que a conexão será fechada mesmo que ocorra algum erro.
 // Não existe problema em fechar uma conexão duas vezes. 
 // O problema está em abrir uma conexão duas vezes.
 //
 if (conn != null)
 {
 conn.Close();
 }
 }
 return true;
 }
131
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
6.1.2 Método ObterConexão
Esse	método	tem	por	finalidade	prover	informações	de	alocação	do	banco	de	dados	no	desktop ou 
em um servidor.
Para o funcionamento desse método, deve‑se:
1. Efetuar a descrição de string de conexão que informa dados do banco que será acessado.
2. Efetuar instância da conexão com a base de dados.
3.	Verificar	se	a	conexão	encontra‑se	fechada.
4.	Abrir	a	conexão.
Método ObterConexao
public OleDbConnection obterConexao()
 {
 OleDbConnection conn = null;
 //
 //string de conexão que informa dados do banco que irei acessar
 //
 string connectionString = @”Provider=Microsoft.ACE.OLEDB.12.0;Data 
Source=C:\ aluno.accdb”;
 //
 //instância da conexão
 //
 conn = new OleDbConnection(connectionString);
 //
 //verifica se conexão está fechada, se tiver abre.
 //
 if (conn.State == ConnectionState.Closed)
 {
 //
 //abre conexão
 //
 conn.Open();
 }
 return conn;
 } 
6.1.3 Método FecharConexao
Esse método será responsável por validar a conexão e, ao final do procedimento de execução, 
fechá‑la.	Toda	conexão	deve	ser	encerrada	ao	final	do	método.
132
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 III
public void fecharConexao(OleDbConnection conn)
 {
 if (conn.State == ConnectionState.Open)
 {
 //
 //fecha conexão
 //
 conn.Close();
 }
 }
Executando a aplicação, teremos o seguinte resultado:
Figura	177 – Valores informados na aplicação CadastroAluno
Após	a	inclusão	de	valores	nas	caixas	de	texto	Nome,	RG	e	CPF,	acionaremos	o	botão	Incluir:
Figura	178 – Dados do aluno incluídos com sucesso
133
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 verificarmos se o registro foi incluído com sucesso iremos até a aba Server Explorer:
•	 Para	adicionarmos	à	nossa	tabela	precisamos	clicar	com	o	botão	direito	em	Data Connections  
Add Connection
Figura	179	–	Inserido	na	solução	um	novo	dataBase
Figura	180	–	Adicionando	Connection	Microsoft	Access	DataBase	File
134
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 III
Figura	181 – Adicionando Connection
Vamos localizar o banco de dados criado utilizando o Access e digitar em Password a senha Admin 
(Senha	default	para	o	acesso).	Após	o	preenchimento	desses	campos	vamos	acionar	o	botão	Test	Connection.
Figura	182	–	Teste	de	conexão
•	 Para	descobrirmos	o	endereço	DataSource informado no método AbrirConexao, inserido na classe 
ctlAluno,	no	projeto	Cadastro_Aluno_Controle,	vamos	efetuar	o	seguinte	passo:
135
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	183 – Acionar com o botão direito a base aluno.accdb e clicar no item Properties
Figura	184 – A propriedade ConnectionString	contém	o	endereço	do	banco	de	dados	que	será	utilizado	no	Método	ObterConexao
136
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 III
Para visualizar a inclusão do item:
Figura	185 – Localizar a tabela tblAluno e, com o botão direito acionado, ir até o item New Query
Figura	186 – Selecionar a tabela tblAluno
137
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
No console SQL, escrever a seguinte instrução:
•	 Select	*	from	tblAluno.	Selecionar	a	query	digitada	e	acionar	a	combinação	de	botões	Crtl	+	R	e	
teremos o seguinte resultado:
Figura	187 – Item incluído com sucesso
Para a apresentação da mensagem de sucesso na tela, a lógica deferida seria:
Figura	188	–	Tratamento	de	sucesso/falha	de	inclusão	de	registro
O	retorno	da	execução	do	Método	Cadastrar	é	do	tipo	booleano	e,	dentro	do	projeto	CadastroAluno,	
o	código	é	tratado	para	a	condicional	composta	(true/false),	ou	seja,	caso	os	dados	estejam	certos,	junto	
com a conexão de dados, o cadastro será realizado com sucesso, senão haverá falha na inclusão do 
cadastro do aluno.
Para os itens de alteração, exclusão e consulta, aplica‑se o mesmo procedimento, tendo como 
paralelos os seus respectivos métodos: Update, Delete e Select.
138
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 III
6.1.4 Método Alterar
Método responsável por efetuar a exclusão de valores na tabela alocada em uma base de dados. Para 
que a integridade da alteração seja atendida, vale ressaltar a importância de se informar, na cláusula 
Where, qual registro deverá ser alterado.
public bool Alterar(string rg, string cpf)
 {
 string query = “UPDATE tblAluno SET cpf = “ + cpf + “ WHERE rg = ‘” 
+ rg + “’;
 OleDbDataReader reader = null;
 OleDbConnection conn = null;
 try
 {
 conn = obterConexao();
 //
 // Criação do objetocomando, que recebe a query que será uti-
lizada na operação e a conexão com o banco.
 //
 OleDbCommand cmd = new OleDbCommand(query, conn);
 //
 // Executa comando
 //
 
 reader = cmd.ExecuteReader();
 //
 //interage com a tabela retornada
 //
 while (reader.Read())
 {
 return true;
 }
 fecharConexao(conn);
 }
 catch (Exception ex)
 {
 throw ex;
 }
 finally
 {
 //
 // Garante que a conexão será fechada mesmo que ocorra algum erro.
 // Não existe problema em fechar uma conexão duas vezes. 
 // O problema está em abrir uma conexão duas vezes.
 //
 if (conn != null)
 {
 conn.Close();
 }
 }
 return true;
 }
139
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
6.1.5 Método Excluir
Método responsável por efetuar a exclusão de valores na tabela alocada em uma base de dados. Para 
que a integridade da exclusão seja atendida, vale ressaltar a importância de se informar, na cláusula 
Where, qual registro deverá ser excluído.
public bool Excluir(string rg)
 {
 string query = “DELETE FROM tblAluno WHERE rg = ‘” + rg + “’”;
 OleDbDataReader reader = null;
 OleDbConnection conn = null;
 try
 {
 conn = obterConexao();
 //
 // Criação do objeto comando, que recebe a query que será uti-
lizada na operação e a conexão com o banco.
 //
 OleDbCommand cmd = new OleDbCommand(query, conn);
 //
 // Executa comando
 //
 
 reader = cmd.ExecuteReader();
 //
 //interage com a tabela retornada
 //
 while (reader.Read())
 {
 return true;
 }
 fecharConexao(conn);
 }
 catch (Exception ex)
 {
 throw ex;
 }
 finally
 {
 //
 // Garante que a conexão será fechada mesmo que ocorra algum 
erro.
 // Não existe problema em fechar uma conexão duas vezes. 
 // O problema está em abrir uma conexão duas vezes.
 //
 if (conn != null)
 {
 conn.Close();
 }
 }
 return true;
 }
140
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 III
6.1.6 Método ObterAluno
Método responsável por efetuar a consulta de valores na tabela alocada em uma base de dados. Para 
que a integridade da consulta seja atendida, vale ressaltar a importância de se informar, na cláusula 
Where, qual registro deverá ser consultado.
public mdlAluno	obterAluno(mdlAluno mdlAluno)
 {
 string	query	=	“SELECT	*	FROM	tbAluno	WHERE	UPPER(alun)	=	‘”	+	mdlAluno.Aluno.ToUpper()	+	“’”;
 OleDbDataReader	reader	=	null;
 OledbConnection	conn	=	null;
 mdlAluno	aluno	=	null;
 try
 {
																conn	=	obterConexao();
 //
 // Criação do objeto comando, que recebe a query que será utilizada na operação e a conexão 
com o banco.
 //
 OledbCommand	cmd	=	new OledbCommand(query,	conn);
																reader	=	cmd.ExecuteReader();
 if	(reader.HasRows)
 {
 while	(reader.Read())
 {
																								aluno	=	new mdlAluno();
																								aluno.nome	=	reader.GetString(2);
																								aluno.rg	=	reader.GetInt32(3);
																								aluno.cpf	=	reader.GetInt32(4);
 return aluno;
 }
 }
																reader.Close();
																fecharConexao(conn);
 return usuario;
 }
 catch	(Exception	ex)
 {
 throw ex;
 }
 finally
 {
 //
 // Garante que a conexão será fechada mesmo que ocorra algum erro.
 // Não existe problema em fechar uma conexão duas vezes. 
 //	O	problema	está	em	abrir	uma	conexão	duas	vezes.
141
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
 //
 if	(conn	!=	null)
 {
																				conn.Close();
 }
 }
 }
 resumo
Tratamos	 do	 desenvolvimento	 em	 si,	 desde	 a	 camada	 visual	 até	 as	
camadas de modelo e de controle.
A camada de apresentação, chamada de View	(Visualização		Interface),	
contém os elementos da interface do usuário do site e inclui toda a lógica 
de	interação	do	visitante	e	das	regras	de	negócio	(Windows	Form).
A camada Controller	 (controle)	 recebe	 a	 requisição	 da	 camada	 de	
apresentação e retorna o resultado dependendo da lógica de negócio 
(Classes	C#).
A camada de acesso a dados contém as classes que acessam o banco de 
dados	e	retornam	o	resultado	da	camada	de	negócio	(Classes	C#).
Camada de 
apresentação ‑ 
Windows Form
Camada de 
negócio ‑ Classe 
C#
Camada de 
acesso a dados
Figura	189	–	Fluxo	de	Execução	de	Desenvolvimento
Camada Model (Projeto Modelo): nesse projeto estarão contidas todas 
as	classes	que	“remetem”	ao	banco	de	dados,	ou	seja,	por	meio	dessa	classe	
podemos	fazer	uma	“cópia”	da	nossa	estrutura	de	tabela.	Por	exemplo:
Quadro 7 – Estrutura da Tabela Usuário
tbUsuario
id – int – PK
loginUsuario	–	varchar(20)
senha	–	varchar(8)
Nome	–	varchar(30)
142
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 III
tbUsuario – Nome da tabela Usuário;
id, loginUsuario, senha, nome – atributos da tabela Usuário
Estrutura de classe (C#)
Public: informa que o atributo a ser adicionado na classe terá 
“visibilidade”	no	projeto.
Int, string, DateTime, float, decimal: são os tipos que os atributos 
irão	receber	(este	dado	deve	ser	igual	ao	informado	no	momento	da	criação	
da	tabela).
Get/Set (Enviar/Receber):	informações	por	meio	da	navegação	entre	
os projetos.
É importante lembrar que a classe usuário foi adicionada ao projeto Model.
Camada Controller (Projeto Controller): responsável por receber 
os parâmetros enviados pela interface e tratar, dentro de suas respectivas 
classes,	 a	 regra	 de	 negócio	 por	 meio	 de	 métodos	 (por	 exemplo:	
consultarUsuario,	alterarUsuario,	excluirUsuario,	inserirUsuario).
Classe ctlUsuario
143
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
Notem que no método Cadastrar	é	colocada	a	palavra	bool	(Boolena),	
que indica que o retorno da camada de dados será do tipo true/false. Dentro 
da classe login podemos inserir todos os métodos essenciais para uma tela 
(Consultar,	Excluir,	Deletar,	Alterar).
Lembrando que a classe ctlUsuario também foi adicionadaao 
projeto Controller.
Camada de Dados (Projeto Dados – Opcional): responsável por 
receber os parâmetros da camada controller	 e	 efetuar	 as	 devidas	 ações	
no	banco	de	dados	por	meio	de	métodos	inseridos	na	classe	(por	exemplo:	
consultarUsuario,	excluirUsuario,	inserirUsuario,	alterarUsuario).
usuarioDAL.cs
Notem que existe o Método Cadastrar, que recebe os parâmetros login, 
senha e nome fornecidos pela camada Controller.
Assim como nos exemplos anteriores, a classe usuarioDAL foi adicionada 
ao projeto Dados.