S2B – Student to Business

Laboratório – Orientação a Objeto com C#

Laboratório
Orientação a Objeto com C#

Índice

PARTE I – Estruturado 3
Introdução 3

Criação da Interface 3

Programando 4

PARTE II – Orientação a Objeto 5

Introdução 5

Criação da Classe 5

PARTE III – Herança 7

Introdução 7

Criação da Interface 7

Criação da Classe 7

PARTE IV – Tratando Exceções 10

Introdução 10

Entendendo a modificação 10

12
Laboratório
Orientação a Objeto com C#

PARTE I – Estruturado
Introdução
Este laboratório tem como objetivo construir um simples sistema de gerenciamento de porta,
de forma estruturada, que será convertido para POO posteriormente.

Criação da Interface
Para criar a interface deste exercício, primeiramente adicione as seguintes imagens ao projeto:

Fig 1 – Imagens disponibilizadas

É possível adicionar alguns arquivos externos ao projeto para facilitar o seu uso. São os
Resources. Para adicionar um, dê um duplo clique em “Properties” no Solution Explorer. Depois
que aparecerem as propriedades do seu projeto, clique na aba Resources, à esquerda e
adicione as imagens (Fig 2):

Fig 2 – Add Resource

Agora as imagens fazem parte do seu projeto. Para acessá-las, basta acessar o namespace
GerenciamentoDePortas.Properties.Resources e todos os resources que você
acabou de adicionar estarão lá em forma de imagem. Para facilitar o acesso, importe o
namespace GerenciamentoDePortas.Properties, assim o acesso ficará mais fácil.

Com as imagens inseridas, vamos à interface. O projeto consiste em um gerenciador de porta,

onde é possível abrir, fechar, trancar e destrancar uma porta. Para isso usaremos as imagens
que foram adicionadas anteriormente. A interface deve ser parecida com a Fig 3:

12
Laboratório
Orientação a Objeto com C#

Fig 3 – Interface do projeto

O único controle que precisa de explicação é o seguinte:

1. picPorta – PictureBox

a. Image: GerenciamentoDePortas.Properties.Resources.opened

b. SizeMode: StretchImage

Programando
Para gerenciar o estado da porta, crie duas variáveis: “aberta” e “trancada” do tipo Bool. A
porta deverá iniciar aberta e destrancada. Ou seja, no evento Load do formulário, sete a
variável “aberta” como True e a “trancada” como False.

Agora crie 4 funções: Abrir(), Fechar(), Trancar() e Destrancar(). A única coisa que cada botão
vai fazer é chamar a função correspondente o botão btnAbrir vai chamar a função Abrir(), e
assim por diante).

Cada função deverá fazer uma verificação se é possível fazer o procedimento desejado. Se for,
alterar o estado da variável em questão e alterar a imagem do picPorta. Por exemplo: se a
porta já estiver aberta, não é possível abri-la novamente. Só é possível abrir a porta se ela
estiver fechada e destrancada. Então o código da função Abrir() ficará assim:

public void Abrir()

{
if (!aberta && !trancada)
{
aberta = true;
picPorta.Image = Resources.opened;

12
Laboratório
Orientação a Objeto com C#

}
}

Seguindo essa lógica, implemente as funções Fechar(), Trancar() e Destrancar().

PARTE II – Orientação a Objeto

Introdução
Este laboratório pretende melhorar o exercício da porta começado anteriormente,
convertendo-o de uma forma simples para OO. A interface será a mesma.

Criação da Classe
Essa versão do sistema terá apenas uma classe: Porta. A classe Porta será responsável por
gerenciar a porta, contendo as variáveis “aberta” e “trancada” dentro dela, expondo somente
os métodos Abrir(), Fechar(), Trancar() e Destrancar().

A classe deve possuir os seguintes métodos e campos (Fig 4):

Fig 4 – Classe Porta

A diferença dessa classe para o exercício anterior é que dentro dela, há um controle PictureBox,
que é passado no construtor. Ou seja, quando for instanciar um objeto da classe Porta, é
necessário passar um PictureBox por referência. No construtor da classe Porta, é necessário
instanciar o objeto _controleImagem com esse controle passado por referência.

12
Laboratório
Orientação a Objeto com C#

Com a classe pronta, é só ir ao formulário e implementar dessa forma:

public partial class Form1 : Form

{
Porta porta; (1)
public Form1()
{
InitializeComponent();
porta = new Porta(this.picPorta); (2)
}

private void btnAbrir_Click(object sender, EventArgs e)

{
porta.Abrir(); (3)
}

//E assim por diante...

}

Nota (1) – Aqui você está criando um objeto da classe Porta. Você está CRIANDO, mas NÃO
está INSTANCIANDO.

Nota (2) – Agora sim você está INSTANCIANDO o objeto criado. Como a classe Porta exige
obrigatoriamente um objeto do tipo PictureBox, você deve passar a PictureBox que está
utilizando para mostrar as imagens.

Nota (3) – No evento Click de cada botão, apenas chame o método correspondente ao que
o botão faz.

12
Laboratório
Orientação a Objeto com C#

PARTE III – Herança

Introdução
Este laboratório pretende melhorar o exercício da porta começado anteriormente, colocando
em prática os conhecimentos de herança. Será feito o gerenciamento de uma porta e de uma
porta de cofre ao mesmo tempo. A peculiaridade da porta de cofre é que ela já começa
fechada, e para destrancá-la, é necessária uma senha.

Criação da Interface
A interface é parecida com a do exercício anterior, mas serão criados alguns outros controles
para gerenciar a porta de cofre (Fig 5).

Fig 5 – Interface da Parte III do projeto

Criação da Classe
Como descrito na introdução, agora criaremos uma porta de cofre. No mundo real, uma porta
de cofre tem todas as características de uma porta comum. A única diferença é que para
destrancá-la, é necessário ter a mesma senha que foi inserida na tranca quando o cofre foi
criado. Então a melhor forma de criar uma classe PortaDeCofre seria herdando da classe Porta.

Então crie uma nova classe chamada PortaDeCofre e aplique a herança de Porta:

12
Laboratório
Orientação a Objeto com C#

Fig 6 – Diagrama de Classe

Ao aplicar a herança, provavelmente aparecerá uma mensagem de erro. Essa mensagem

acontece pelo seguinte motivo:

A classe Porta tem somente um construtor no qual é obrigado passar um objeto do

tipo PictureBox. Quando PortaDeCofre aplica a herança de Porta, você ainda não
definiu nenhum construtor para PortaDeCofre. E como todas as classes filhas devem
ter construtores que sejam compatíveis com algum construtor da classe pai, portanto
como o .NET não encontrou nenhum construtor compatível, ele mostra tal erro.

Para arrumar a classe PortaDeCofre, crie um construtor que receba como parâmetro um objeto
do tipo PictureBox (assim como na classe Porta) e um outro parâmetro do tipo string para
poder definir a senha do cofre (como já explicado acima).

Agora com o construtor de PortaDeCofre criado, ainda é necessário especificar como acessar o
construtor da classe Porta. Na linha abaixo da declaração do construtor, acrescente a chamada
ao construtor da classe base e passe o parâmetro desejado, como mostra o trecho de código
abaixo:

public PortaDeCofre(System.Windows.Forms.PictureBox Controle,

string Senha)
: base(Controle)
{
//O resto do código...
}

12
Laboratório
Orientação a Objeto com C#

Crie um campo privado para guardar a senha passada no construtor. Como a porta do cofre já
começa fechada e trancada, indique isso também no construtor. Se não conseguir, altere a
visibilidade dos campos “aberta” e “trancada” na classe Porta para que sejam visíveis em todas
as classes filhas.

Sobrescreva o método Destrancar() da classe Porta. Não se esqueça de alterar o que for
necessário na classe Porta para poder sobrescrever tal método. Crie uma sobrecarga desse
método que receba uma string para verificar se é a senha correta para abrir a porta. O método
Destrancar() que está sobrescrevendo deve apenas chamar o método Destrancar() que recebe
a string. Obtendo o seguinte código:

public override void Destrancar()

this.Destrancar("");

public void Destrancar(string Senha)

/*Verifica se a senha está correta.

* Se estiver, chame o método

* destrancar da classe base.*/

A implementação no formulário será feita da mesma forma que no exercício anterior. A

diferença é que para a porta de cofre deverá ser criado e instanciado outro objeto da classe
PortaDeCofre, mas a implementação segue a mesma lógica.

12
Laboratório
Orientação a Objeto com C#

PARTE IV – Tratando Exceções

Introdução
Este laboratório será a versão final do gerenciador de portas. Ele mostrará como implementar o
tratamento de erros e como criar erros personalizados.

Entendendo a modificação
A evolução desta etapa será criar erros personalizados para melhorar a interface com o
usuário. Parece ser estranho, mas no Visual Studio 2005 é muito simples e útil.

Exception é uma classe que representa os erros que ocorrem durante a execução da aplicação.
Ao executar uma operação indevida nas classes do .Net, ele automaticamente dispara uma
exception. Por exemplo, se você tem um vetor de 5 posições e tentar acessar a 10ª posição.
Isso irá disparar uma IndexOutOfRangeException. Essa exceção na verdade é uma classe que
herda a classe Exception.

Você pode fazer uma exceção personalizada também. Para fazê-la, crie uma nova classe com o
nome PortaAbertaException e faça a herança de Exception. Agora crie um construtor que
chame o construtor da classe base, passando simplesmente a mensagem de erro como
parâmetro (algo como “A porta já está aberta”).

Pronto. A sua exceção personalizada está criada. Para dispará-la faça assim em alguma outra
classe:

throw new PortaAbertaException()

Rode o programa e aparecerá uma mensagem de erro típica do Visual Studio 2005, mas com a
mensagem que você passou no construtor da classe base de PortaAbertaException.

12
Laboratório
Orientação a Objeto com C#

Fig 7 – Mensagem de erro

Para tratar o erro, utilize o Try/Catch:

try
{
throw new PortaAbertaException();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}

Aparecerá uma MessageBox com a mensagem do erro que você criou. É muito simples e
elegante utilizar Try/Catch.

Seguindo esta idéia, é possível melhorar a classe Porta. Em cada método, ao invés de somente
verificar se é possível realizar a ação desejada, seria melhor se na impossibilidade de realizar a
ação, fosse disparada uma exceção. Assim ficaria até mais fácil mostrar para o usuário que a
ação não pode ser realizada e por qual motivo.

Por exemplo, o método Abrir() ficaria assim:

public void Abrir()

{
if (this._aberta)

12
Laboratório
Orientação a Objeto com C#

throw new PortaAbertaException();

else if (this._trancada)
throw new PortaTrancadaException();
//O resto do código...
}

O método apenas dispara as exceções necessárias. O “form1” deve se preocupar em tratar as

exceções.

private void btnAbrir_Click(object sender, EventArgs e)

{
try
{
porta.Abrir();
}
catch (Exception ex)
{

MessageBox.Show(ex.Message);
}
}
Agora é possível mostrar ao usuário quando a ação desejada não ocorreu e o porquê disso.
Crie as seguintes classes: (todas elas serão filhas da classe Exception e serão as exceções
personalizadas do sistema)

1. Classe PortaFechadaException

 Exceção disparada ao fechar uma porta fechada.

2. Classe PortaAbertaException

 Exceção disparada ao abrir, trancar ou destrancar uma porta aberta.

3. Classe PortaTrancadaException

 Exceção disparada ao trancar ou abrir uma porta trancada.

4. Classe PortaDestrancadaException

 Exceção disparada ao destrancar uma porta destrancada.

5. Classe PortaSenhaInvalidaException

 Exceção disparada ao abrir uma porta com senha, informando a senha errada.

Todas as cinco classes devem possuir um construtor cada, chamando o construtor de sua classe
mãe, com um único parâmetro do tipo string (a mensagem da qual a exceção trata).

12