1

Este material faz parte do livro “Programação Orientado a Objetos com C#” e está disponível
na disciplina de mesmo nome em nossa Pós-graduação em Arquitetura de Soluções em
Plataforma .Net (C#). Foi escrito pelo nosso professor Alan Lira. Você pode saber mais sobre a
pós entrando em contato por e-mail: contato@uniciv.com.br ou telefone: 0800 006 4224

2
 SUMÁRIO

Conhecendo a linguagem C# 4
Objetivos 4
Classes 4
Atributos 5
Propriedades 5
Métodos 7
Constantes 9
Enumerações 10
Namespaces 11
Arrays 12

3
Conhecendo a linguagem C#
Neste capítulo começaremos de fato a explorar a programação utilizando a linguagem C#,
veremos como criar classes, adicionar propriedades, atributos e métodos a elas, além de
verificar algumas estruturas comuns da linguagem, como estrutura de decisão e repetição.
Por fim veremos o que são namespaces e Enumerações.

Objetivos
Ao final deste capítulo, espero você esteja mais familiarizado com a linguagem C# e que
compreenda os seguintes temas:
● O que são e como criar classes C#
● Tipos do C#
● Como declarar atributos, propriedades e constantes
● Compreender algumas estruturas de decisão e repetição
● Como criar métodos
● Compreender o uso de Namespaces e enumerações.

A linguagem C# é uma linguagem compilada, como já falamos sobre, fortemente tipada e

utiliza tipagem estática, isso significa que ao declarar uma variável em C# devemos dizer
explicitamente seu tipo (tipagem estática) e após declarada não pode ter seu tipo alterado e
só podemos fazer operações entre ela e outras variáveis ou valores do mesmo tipo (tipagem
forte).
A linguagem C# tem também fortes características da Orientação a Objetos, assim como o
Java, e proporciona simplicidade na grande maioria de suas estruturas, possibilitando a
escrita de código de fácil leitura e manutenção. Atualmente o C# encontra-se na versão 7 com
uma infinidade de recursos que foram adicionados durante os anos de sua existência.

Classes
Assim como toda linguagem orientada a objetos o C# utiliza em abundância estruturas
chamadas de classes. Classes são estruturas que podem apresentar características e
comportamentos, vejamos um exemplo básico de uma classe C#:

public class Cliente

{
}

Neste exemplo temos uma classe pública, chamada de Cliente, que irá representar um
conjunto de características e comportamentos que um cliente do mundo real possui, ela
possibilitará que eu crie vários objetos que representem diferentes clientes, cada um com

4
suas características, fazendo uso de um construtor que neste caso existe implicitamente. Para
que eu crie um novo cliente eu devo escrever:

Cliente meucliente = new Cliente();

Atributos
Até o momento não há nada que diferencie um cliente de outro, vamos adicionar
características a ele, utilizando nesse primeiro momento, os atributos:

public class Cliente

{
public int codigo;
public string nome;
public decimal rendaMensal;
public bool clientePremium;
}

Agora cada cliente que eu criar, poderei definir um código, nome, uma renda
mensal diferente e dizer que ele pode ser ou não um cliente premium, de acordo
com uma regra do meu negócio. Para criar um cliente de exemplo, escrevemos:

Cliente meucliente = new Cliente();

meucliente.codigo = 1;
meucliente.nome = "João Da Silva";
meucliente.rendaMensal = 2300;
meucliente.clientePremium = true;

Propriedades
Temos então um objeto cliente que representa um cliente chamado João Da Silva, porém
perceba que criamos todos nossos atributos como públicos, isso quer dizer que minha classe
não tem controle do que são colocados em cada um dos seus atributos e nem quando são
alterados, seria um problema um cliente criado com o código 1 seja alterado para outro
código, sem qualquer critério correto? Para isso teríamos que passar a dar o controle de
quando alterar as informações para nossa classe e para isso vamos transformar nossos
atributos em propriedades:

public class Cliente

5
{
public int Codigo { get; set; }
public string Nome { get; set; }
public decimal RendaMensal { get; set; }
public bool ClientePremium { get; set; }
}

Não parece ter alterado muito nossa classe, não é mesmo? nosso atributos agora começam
com letras maiúsculas (convenção para propriedades) e possuem um { get; set; } na frente
das declarações, isso no momento está indicando somente que todas as nossa propriedades
podem ser lidas e alteradas, mas como ainda continuam públicas, ainda não existem
restrições de quem pode fazer isso, então vamos melhorar isso:

public class Cliente

{
public int Codigo { get; private set; }
public string Nome { get; set; }
public decimal RendaMensal { get; set; }
public bool ClientePremium { get; private set; }
}

Agora a palavra set do nosso atributo Codigo e do nosso atributo ClientePremium receberam
uma palavra private antes, isso indica que, agora somente dentro da minha classe Cliente
estas propriedades podem ser alteradas, mesmo ainda sendo possível lê-las em qualquer
lugar onde este cliente estiver sendo manipulado. Nossa classe agora possui mais controle
sobre suas propriedades, pelos menos propriedades que eu considero mais sensíveis (neste
cenário hipotético), seguindo nosso exemplo, já que agora somente a classe Cliente pode
definir valores para o Codigo e ClientePremium, em que momento podemos fazer isso? Seria
ideal fazermos isso somente quando um cliente é criado, não é mesmo? para isso vamos
definir um construtor personalizado:

public class Cliente

{
public Cliente(int codigo, string nome, decimal rendaMensal)
{
Codigo = codigo;

6
 Nome = nome;
RendaMensal = rendaMensal;
ClientePremium = RendaMensal >= 5000
}

public int Codigo { get; private set; }

public string Nome { get; set; }
public decimal RendaMensal { get; set; }
public bool ClientePremium { get; private set; }
}

Neste caso, no momento que criarmos um cliente é necessário atender os requisitos dele e
fornecer os dados codigo, nome e rendaMensal em forma de parâmetros e o construtor se
responsabilizará em definir estes valores nas nossas propriedades, sendo assim, um cliente
com o código 1 após ser criado não poderá receber outro código, além disso implementamos
uma regra de negócio que indica que um cliente será premium se a renda mensal inicial for
maior ou igual que R$ 5.000, e essa definição uma vez definida no construtor não poderá
ser alterada por intervenções externas a nossa classe. Vamos verificar com criar um cliente
agora?

Cliente meucliente = new Cliente(1, "João da Silva", 2500);

Métodos
Imagine agora que a renda não é o único fator que define quando um cliente é premium, ele
pode ser promovido à cliente premium de acordo com um valor ou quantidade de compras
efetuadas, mas nesse caso nosso cliente já existe e será promovido, alterando o atributo
ClientePremium de false para true, como ClientePremium é um atributo privado, a classe
Cliente deve se responsabilizar por possibilitar essa ação, você deve se lembrar que citei que,
uma classe pode ter características e comportamentos e é isso que vamos definir agora para
nossa classe, um comportamento utilizando um Método:

public class Cliente

{
public Cliente(int codigo, string nome, decimal rendaMensal)
{
Codigo = codigo;
Nome = nome;
RendaMensal = rendaMensal;
ClientePremium = RendaMensal >= 5000
}

7
 public int Codigo { get; private set; }
public string Nome { get; set; }
public decimal RendaMensal { get; set; }
public bool ClientePremium { get; private set; }

public void PromoverCliente()

{
ClientePremium = true;
}
}

Agora um cliente existente pode ser promovido a cliente premium após ser criado, vejamos
como poderíamos consumir este método:

Cliente meucliente = new Cliente(1, "João da Silva", 2500);

// Aqui meucliente.ClientePremium é false
meucliente.PromoverCliente();
// Aqui meucliente.ClientePremium passa a ser true

Perceba que disponibilizamos a funcionalidade de promover cliente por meio de um método

público, e sendo público qualquer lugar onde o cliente for manipulado ele poderá ser
promovido sem restrições, podendo ocasionar algo inesperado, então vamos assegurar que
um cliente seja promovido somente se ele atender a certos critérios definidos no nosso
negócio:

public bool PromoverCliente(decimal valorEmCompras)

{
if (valorEmCompras >= 8000)
{
ClientePremium = true;
return true;
}
return false;
}

O cliente agora deve ter pelo menos R$ 8.000 em compras efetuadas para ser promovido e
como feedback para quem utilizar esse método estou retornando true em caso de sucesso ao
promover o cliente e false em caso de falha, utilizando a estrutura de decisão if e neste caso
não há necessidade de um else (fluxo executado quando um cliente não possuir

8
valorEmCompras de no mínimo R$ 8.000) pois após a palavra-chave return, nenhum outro
código deste método é executado impedindo que um cliente que foi promovido retorne false
para seu utilizador.

Constantes
Com nossa classe cliente já bem definida, é um momento para refatorarmos um pouco o
código e definirmos valores importantes de nossas regras como constantes, isso facilita a
leitura do código e possíveis alterações serão mais simples:

public class Cliente

{
private const decimal RENDA_MINIMA = 5000;
private const decimal VALOR_MINIMO_EM_COMPRAS = 8000;

public Cliente(int codigo, string nome, decimal rendaMensal)

{
Codigo = codigo;
Nome = nome;
RendaMensal = rendaMensal;
ClientePremium = RendaMensal >= RENDA_MINIMA
}

public int Codigo { get; private set; }

public string Nome { get; set; }
public decimal RendaMensal { get; set; }
public bool ClientePremium { get; private set; }

public bool PromoverCliente(decimal valorEmCompras)

{
if (valorEmCompras >= VALOR_MINIMO_EM_COMPRAS)
{
ClientePremium = true;
return true;
}
return false;
}
}

Neste caso, como o próprio nome sugere o valor de constantes não podem ser alterados
depois de definidos e se você tentar fazer isso o compilador lhe alertará e não conseguirá
efetuar a compilação.

9
Enumerações
Continuando com nosso modelo de negócio, nossa classe cliente agora terá que possibilitar
um novo nível de classificação de clientes e não somente ser ou não um cliente premium,
esse novo nível se chamará MASTER, como prever isso no nosso código? Eu poderia criar
outra propriedade booleana indicando quando um cliente é master, porém se tornaria
trabalhoso identificar o nível de classificação de um cliente ou até mesmo alterá-lo, e se a
cada novo nível eu tiver que criar uma nova propriedade, se tornará insustentável, não é
mesmo? Para isso vamos utilizar um recurso chamado Enumerações que será definido logo
abaixo:

public enum EClassificacao

{
Convencional,
Premium,
Master
}
public class Cliente
{
private const decimal RENDA_MINIMA_PREMIUM = 5000;
private const decimal RENDA_MINIMA_MASTER = 8500;
private const decimal VALOR_MINIMO_EM_COMPRAS_PREMIUM = 8000;
private const decimal VALOR_MINIMO_EM_COMPRAS_MASTER = 10000;

public Cliente(int codigo, string nome, decimal rendaMensal)

{
Codigo = codigo;
Nome = nome;
RendaMensal = rendaMensal;
Classificacao = DefinirClassificacao();
}

public int Codigo { get; private set; }

public string Nome { get; set; }
public decimal RendaMensal { get; set; }
public EClassificacao Classificacao { get; private set; }

private EClassificacao DefinirClassificacao()

{
if (RendaMensal < RENDA_MINIMA_PREMIUM )

10
 {
return EClassificacao.Convencional;
}
if (RendaMensal < RENDA_MINIMA_MASTER)
{
return EClassificacao.Premium;
}
return EClassificacao.Master;
}
}

Nossa classe está ficando extensa não é mesmo? Vou deixar para que você imagine como
definir o método PromoverCliente, veja que agora alteramos o ClientePremium para
Classificacao e o tipo dele agora se tornou uma enumeração, isso significa que essa
propriedade deve conter somente valores definidos na nossa enumeração, além disso criei
um método privado (somente a classe cliente pode utilizá-lo) para definir qual a classificação
nosso cliente irá se enquadrar.
Obs: Uma dica é que você pode definir valor inteiros para os valores da coleção, caso seja
mais significativo, exemplo:

public enum EClassificacao

{
Convencional = 0,
Premium = 1,
Master = 2
}

Namespaces
Vamos aproveitar que a classe Cliente ficou um pouco extensa e vamos organizá-la de forma
que fique separada da enumeração, e para isso vamos utilizar Namespaces, eles são uma
parte importante da identificação e organização não só de classes, mas também de
enumerações e outras estruturas, vou utilizar como exemplo a separação da classe Cliente
em um namespace Classes e a enumeração EClassificacao em um namespace Enumeracoes,
vejamos como fica:

namespace Enumeracoes
{
public enum EClassificacao
{

11
 Convencional,
Premium,
Master
}
}

using Enumeracoes;

namespace Classes
{
public class Cliente
{
public EClassificacao Classificacao { get; private set; }
}
}

Em um caso real a classe Cliente e a enumeração EClassificacao estariam em arquivos

distintos além de namespaces, mas como se trata de um exemplo didático, não vamos nos
atentar a isso. Perceba que agora que separamos em namespaces, estou utilizando uma nova
palavra chave, chamada using, isso é necessário para deixar explícito de onde a enumeração
EClassificacao se encontra, pois namespaces podem ser compostos e geralmente transmitem
a localização em pastas do artefato. Comumente os namespaces são definidos de forma que
o primeiro agrupamento seja o nome da aplicação e depois, separados por pontos, os nomes
das pastas até chegar no artefato em questão, vejamos um exemplo:

namespace MinhaAplicacao.Vendas.Classes
{
public class Cliente
{
}
}

Nesse caso, nossa classe cliente faz parte de um projeto chamado “MinhaAplicacao” e está
dentro de um pasta “Classes” que por sua vez se encontra numa pasta chamada “Vendas”.

Arrays
Agora vamos voltar a nossa classe cliente e imaginar que precisamos receber os e-mails que
nosso cliente possui e para isso vamos utilizar um array:

12
 namespace Classes
{
public class Cliente
{
public Cliente(int codigo, string nome, decimal rendaMensal,
string[] emails)
{
Codigo = codigo;
Nome = nome;
RendaMensal = rendaMensal;
Classificacao = DefinirClassificacao();
Emails = emails;
}

public int Codigo { get; private set; }

public string Nome { get; set; }
public decimal RendaMensal { get; set; }
public EClassificacao Classificacao { get; private set; }
public string[] Emails { get; private set; }
}
}

Para definir uma propriedade do tipo array devemos utilizar o tipo seguido de colchetes,
indicando que se trata de uma estrutura de vários valores. Agora, para que possamos utilizar
os valores desta propriedade, para gerar uma lista de e-mails do cliente por exemplo,
podemos utilizar uma estrutura de repetição:

namespace Classes
{
public class Cliente
{
public Cliente(int codigo, string nome, decimal rendaMensal,
string[] emails)
{
Codigo = codigo;
Nome = nome;
RendaMensal = rendaMensal;
Classificacao = DefinirClassificacao();
Emails = emails;

13
 }

public int Codigo { get; private set; }

public string Nome { get; set; }
public decimal RendaMensal { get; set; }
public EClassificacao Classificacao { get; private set; }
public string[] Emails { get; private set; }

public string GerarListaDeEmails()

{
var listaEmails = "O cliente possui " + Emails.Length +
" e-mails:\n";
foreach(var email in Emails)
{
listaEmails += email + "\n";
}
return listaEmails;
}
}
}

Nesse novo método você pode ver o uso de uma estrutura de repetição: O ForEach, ele tem a
função de repetir o bloco contido dentro de suas chaves, de acordo com a quantidade de
elementos dentro de um array, além disso, ele armazena o elemento corrente em uma
variável que chamamos de iterador, nesse caso representado pelo nome email, perceba
também que estou apresentando uma nova palavra chave, a palavra var, ela está sendo
usada para evitar que eu tenha que definir o tipo do iterador e o tipo da minha variável de
retorno (listaEmails) responsável por armazenar minha representação da lista de e-mails, ela
é muito utilizada pois simplifica a declaração de variáveis, porém, só pode ser utilizada em
escopo de métodos ou construtores, como no código acima, não sendo possível declarar
propriedades ou atributos de uma classe utilizando-se dela por exemplo, nesse caso temos
que definir explicitamente o tipo.

Considerações Finais
Neste capítulo vimos muitos recursos interessantes da linguagem C#, começamos pelas
classes definindo uma chamada Cliente e fomos a incrementando com características e
comportamentos, as características representadas primeiramente na forma de atributos e
posteriormente em propriedades e os comportamentos representados pelos métodos. Para
suportar nossos cenários de negócio vimos estruturas de decisão, constantes, enumerações,
namespaces, além de ter uma breve introdução de estruturas de repetição que vamos voltar

14
a vê-las quando chegarmos na parte de Coleções, no próximo capítulo continuaremos a
explorar o uso de Orientação a Objetos em C#, porém veremos conceitos mais avançados.

Este material faz parte do livro “Programação Orientado a Objetos com C#” e está disponível
na disciplina de mesmo nome em nossa Pós-graduação em Arquitetura de Soluções em
Plataforma .Net (C#). Foi escrito pelo nosso professor Alan Lira. Você pode saber mais sobre a
pós entrando em contato por e-mail: contato@uniciv.com.br ou telefone: 0800 006 4224

15