Comportamentos de uma Classe, Propriedades e variáveis, Métodos, Parâmetros, Retorno, Sobrecarga, Parâmetros opcionais, Parâmetros de saída e por referência, Enums, Herança, Classe e métodos estáticos, Conversões, Interfaces, Construtores,

Comportamentos de uma classe

Classes,

Propriedades e variáveis,

Métodos,

Parâmetros,
Retorno,
Sobrecarga,Parâmetros opcionais,Parâmetros de saída e por referência,Enums,
Herança,Classe e métodos estáticos,Conversões,Interfaces,Construtores.



Classes
          Uma classe é uma unidade lógica que reúne as propriedades, ou seja, as características sobre ela mesma e as suas ações representadas pelos métodos que serão abordados com maior profundidade nesse capítulo. Uma classe descreve os serviços providos por seus objetos e quais informações eles podem armazenar. Em C# todas as ações são baseadas em classes de maneira que não podemos definir um método fora do escopo de uma classe. Uma declaração de classe ou estrutura é como um desenho que é usado para criar instâncias ou objetos em tempo de execução. Se você definir uma classe ou estrutura chamada Pessoa, Pessoa é o nome do tipo. Se você declara e inicializa uma variável p tipo Pessoa, p é considerado um objeto ou instância de Pessoa. Uma classe pode ter basicamente construtores, propriedade e métodos, cada um desses itens será abordado separadamente sem seguida.

A sintaxe básica para criação de uma classe em c# é a seguinte.
[Modificador de visibilidade] class [Nome da classe]
{
//Definição da classe
}

Tudo que está entre as duas chaves que delimitam o escopo da classe fazem parte da mesma.

Propriedades e variáveis
          Propriedades e variáveis da classe são dados armazenados pela classe e a diferença entre ambas é que as variáveis normalmente são utilizadas para processamentos internos da classe enquanto as propriedades são utilizadas para expor suas características à outros objetos, em C# é entendido como propriedade dados que façam uso de getters e setters para que outros objetos acessem suas informações, uma variável com modificador público não é considerada uma propriedade, pois os outros objetos tem acesso direta a mesma e isso não é desejável. Já com getter e setter por mais que aparentemente o acesso é direto o valor passa por um tratamento antes.

A sintaxe básica de uma propriedade é:

[Modificador de visibilidade] [Tipo] [Nome da propriedade]
{
//Ao menos um dos modificadores abaixo é necessário, mas não é obrigatório ter ambos ao mesmo tempo.
//O get significa que outros objetos poderão visualizar o valor da propriedade
get;
//O set significa que outros objetos poderão atribuir o valor da propriedade
54 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
set;
}
Exemplo de propriedade
public string Nome
{
get;
set;
}

Construtores

          Construtor é uma espécie de métodos especial que não precisa ser invocados explicitamente, pois isso ocorre quando realizamos a criação de um objeto do tipo da classe, eles devem ter o mesmo nome da classe, não possuir um tipo de retorno definido, uma mesma classe pode ter vários construtores, com tanto que cada um receba parâmetros diferentes, os construtores são amplamente utilizados para inicialização das propriedades e variáveis da classe. A sintaxe básica de um construtor é:

[Modificador de visibilidade] [nome da classe]([parâmetros(opcional)]

{
//Definição do construtor.
}

Exemplo:
class Pessoa 

     {
     string _nome;
     string _cpf;

public string Nome 

     {
      get {  return _nome; }
      set { _nome = value;}
     }
public string Cpf
     {
     get{return _cpf;}
     set{_cpf = value;}
     }
/*
Esse primeiro construtor não recebe nenhum parâmetro e só inicializa as variáveis
com um valor vazio.
*/

public Pessoa() {
_nome = string.Empty;
_cpf = string.Empty;
}
/*
Esse segundo construtor inicia a váriavel Nome com o valor passado como parâmetro.
Um construtor pode chamar outro, aqui está chamando o construtor default, que inicializa as variáveis com valor vazio antes de atribuir valor ao nome, a parte onde está escrito ":this()" é que indica que o construtor default deve ser chamado.
*/
public Pessoa(string Nome):this() {
this._nome = Nome;
}
/*
Esse terceiro construtor inicia a váriavel Cpf e repassa a tarefa de iniciar a váriavel nome
* ao construtor que já sabe como fazer isso, dessa forma evitamos duplicar um código que faz a mesma coisa.
* Nesse caso o que acontece, o terceiro construtor chama o segundo que chama o primeiro, então primeiro as variáveis
* são atribuídas para valor vazio, depois a váriavel nome é atribuída e por último a váriavel _cpf é atribuída.
*/
public Pessoa(string Nome, string Cpf):this(Nome) {
this._cpf = Cpf;
}
}
class Program
{
static void Main(string[] args)
{
//Declaração de uma váriavel pessoa.

Pessoa pess;
//Criação do objeto através do construtor default
//O que define o construtor que será chamado é os parâmetros passado na hora da criação.
//Como não passei nenhum será chamado o construtor default.
pess = new Pessoa();
MostraNomeCpf(pess.Nome, pess.Cpf);
//Saída = Nome:Vazio;CPF:Vazio
//Como passei uma string o segundo construtor será chamado.
pess = new Pessoa("Joaquin");
MostraNomeCpf(pess.Nome, pess.Cpf);
//Saída = Nome:Joaquin;CPF:Vazio
//Como passei 2 strings o terceiro construtor será chamado.
pess = new Pessoa("Joaquin","35783627860");
MostraNomeCpf(pess.Nome, pess.Cpf);
//Saída = Nome:Joaquin;CPF:35783627860
Console.ReadKey();
}
static void MostraNomeCpf(string nome, string cpf) {
if(nome==string.Empty)
nome="Vazio";
if(cpf==string.Empty)
cpf="Vazio";
Console.WriteLine("Nome:{0}; CPF:{1}", nome, cpf);
}
}

Métodos

          Um método é um bloco de código que contém uma série de instruções. O programa executa as instruções quando chamamos o método e especificamos argumentos, em C# todas as instruções são executadas por métodos. 

O método Main é o ponto de entrada para cada aplicativo C# e ele é chamado pelo CLR (Common Language Runtime) quando o programa é iniciado. 

Assinatura de métodos

Métodos são declarados em uma classe ou struct, especificando-se o nível de acesso como public ou private, modificadores opcionais como abstract ou sealed, o valor de retorno e o nome do método. Essas partes juntos são o assinatura do método.

Observação:

Um tipo de retorno de um método não é parte da assinatura do mesmo para fins de sobrecarga. No entanto, ele é parte da assinatura do método ao determinar a compatibilidade entre um delegate e o método que ele aponta.

Os parâmetros do método são colocados entre parênteses e são separados por vírgulas. Parênteses vazios indicam que o método não requer parâmetros.

Sintaxe do método:

[Modificador de visibilidade] [Modificador opcional] [Nome do método]([Lista de parâmetros])
{
//Definição
}
Exemplo:
//O método abaixo não retorna nenhum valor, está acessível a qualquer elemento e recebe uma string como parâmetro
public void Pessoa(string Nome)
{
//Definição
}

Parâmetros

          Os parâmetros são valores que o método necessita para realizar suas operações, ao declarar o método devem ser especificados entre os parênteses com o tipo explicito.
Exemplo:
//O método abaixo aceita um inteiro e uma string como parâmetros, que necessariamente precisam ser passados na chamada.
public void ExcutaAcao(int inteiro, string texto)
{

}

     A maneira mais comum de passar os parâmetros na chamada é como no código abaixo, respeitando a ordem em que foram definidos.
pess.ExcutaAcao(1, "a");

Mas em C# os parâmetros podem ser passados fora de ordem, porém dessa manei precisa ser especificado o nome do parâmetro seguido do valor desejado, exemplo:

pess.ExcutaAcao(texto: "a", inteiro: 1);

Os valores passados como parâmetros recebem o nome de argumentos.

Retorno

          O retorno do método é o tipo de dado que o mesmo devolve ao terminar seu processamento, quando definimos um tipo de retorno no método o compilador exige um código que garanta o retorno de dados com tipo compatível, a palavra reservada “void” é utilizada em métodos que não precisam retornar nenhuma informação. A palavra chave para retorno de dados é “return” a execução do método é interrompida quando a execução passar por um “return”.

Exemplos

//Esse método não retorna nenhuma informação à chamada
public void ExcutaAcao(int inteiro, string texto)
{
//Definição
}
//Esse método retorna uma string concatenando os dois parâmetros
public string ExcutaAcao(int inteiro, string texto)
{
return texto + inteiro.ToString();
}

Sobrecarga
           Sobrecarga de método é a possibilidade de termos métodos diferentes com o mesmo nome diferindo apenas em seus parâmetros, Isso é possível porque o método é identificado na chamada não só pelo seu nome, mas também pelos argumentos recebidos. Esse recurso nos ajuda a manter a semântica do código.
Exemplo
class Pessoa2 {
public string FormataDados(string Nome) {
return "Nome:" + Nome;
}
public string FormataDados(string Nome, string Cpf) {
return "Nome:" + Nome + " Cpf:" + Cpf;
}
}
class Program
{
static void Main(string[] args)
{
Console.WriteLine(new Pessoa2().FormataDados("Vinicius"));
//Saída = Nome:Vinicius
Console.WriteLine(new Pessoa2().FormataDados("Vinicius", "01234567890"));
//Saída=Nome:Vinicius Cpf:01234567890
}


Parâmetros opcionais
           Em C# podemos ter parâmetros opcionais nos métodos, isso significa que na chamada não é necessário passar todos os parâmetros definidos na assinatura do método, isso é possível definindo um valor padrão para o parâmetro o qual é usado no caso de não ser especificado na chamada. Isso pode ser útil quando precisamos acrescentar um novo parâmetro em um método usado muitas vezes na aplicação e desejamos que ele continuasse funcionando da mesma maneira de antes onde já foi utilizado.

Exemplo

//Nesse caso se o cpf não for especificado na chamada.
//O nome será exibido e no lugar do Cpf a palavra "Vazio" aparecerá.
public string FormataDados(string Nome, string Cpf="")
{
if (Cpf == "")
Cpf = "Vazio";
return "Nome:" + Nome + " Cpf:" + Cpf;
}


Parâmetros de saída e por referência
           Os parâmetros de saída são uma forma de um método retornar mais valores além do seu retorno, há situações em que, por exemplo, precisamos converter um valor sem retornar exceção, podemos usar o retorno do método para dizer se a conversão foi um sucesso e um parâmetro de saída com o valor do convertido. Os parâmetros de saída são identificados pela palavra reservada “out” precedendo o tipo do parâmetro, um parâmetro de saída só pode receber como parâmetro um variável de tipo compatível e nunca um valor literal, a palavra reservada “out” também tem que preceder o argumento na chamada, o método é obrigado pelo compilador a atribuir um valor ao argumento. Passagem por referência é quando passamos a instância diretamente para o método que consegue fazer modificações na mesma que refletem no escopo em que foi definida, quando não fazemos isso e alteramos instância dentro do método isso não reflete no escopo em que ela foi definida.

Exemplos

class Program2
{
static void Main(string[] args)
   {
   //Parâmetro por referência
   PessoaSimp pess = new PessoaSimp();
   pess.Nome = "Nome escopo classe";
   pess.CPF = "Cpf escopo classe";
   Console.WriteLine("Classe");
   pess.ExibeDados();
   //Saida = Nome:Nome escopo classe Cpf:Cpf escopo classe
   Console.WriteLine("Método");
   AlteraPessoa(pess);
   //Saida = Nome:Nome escopo método Cpf:Cpf escopo método
   Console.WriteLine("Classe");
   pess.ExibeDados();
   //Saida = Nome:Nome escopo classe Cpf:Cpf escopo classe
   Console.WriteLine("Método");
   AlteraPessoa(ref pess);
   //Saida = Nome:Nome escopo método Cpf:Cpf escopo método
   Console.WriteLine("Classe");
   pess.ExibeDados();
   //Saida = Nome:Nome escopo método Cpf:Cpf escopo método
   //Parâmetro de saída
   int val;
   if (StringToInt("1",out val))
   Console.WriteLine("Conversão bem sucedida valor={0}", val);
   else
   Console.WriteLine("Conversão falhou");
   Console.ReadKey();
   }
static void AlteraPessoa(PessoaSimp pess)
   {
   pess = new PessoaSimp();
   pess.Nome = "Nome escopo método";
   pess.CPF = "Cpf escopo método";
   pess.ExibeDados();
   }
  static void AlteraPessoa(ref PessoaSimp pess) {
  pess = new PessoaSimp();
  pess.Nome = "Nome escopo método";
  pess.CPF = "Cpf escopo método";
  pess.ExibeDados();
}

Enums

          A palavra-chave enum é usada para declarar uma enumeração, um tipo distinto que consiste em um conjunto de constantes nomeadas denominada lista de enumerador. Geralmente é melhor definir um enum dentro de um namespace para que todas as classes no namespace possam acessá-lo com igual conveniência. No entanto, um enum também pode ser aninhado dentro de uma classe ou struct. As constantes têm um valor numérico relacionado. Por padrão iniciando em 0 e aumentando em 1 a cada uma. Mas esse valor também pode ser atribuído explicitamente.
Sintaxe básica de um enum:

Enum{[Constantes separadas por vírgula]};

Exemplo de um enumerador com os dias da semana.
enum Days {Sat, Sun, Mon, Tue, Wed, Thu, Fri};

Enumeradores podem usar os inicializadores para substituir os valores padrões, conforme mostrado no exemplo a seguir.
enum Days {Sat=1, Sun, Mon, Tue, Wed, Thu, Fri};
Utilizando um enum
enum DiasDaSemana {Segunda,Terça,Quarta,Quinta,Sexta}
static string AnalisaDiaSemana(DiasDaSemana Ds)
{
switch (Ds)
     {
     case DiasDaSemana.Segunda:
     return "Ta começando...";
     case DiasDaSemana.Terça:
     return "Força...";
     case DiasDaSemana.Quarta:
     return "Estamos na metade...";
     case DiasDaSemana.Quinta:
     return "Vespera de sexta...";
     case DiasDaSemana.Sexta:
     return "AwwwwwwwwwwwwwIeeeeeee";
     default:
     return "Final de semana";
     }
}
O método retorna um texto em função do valor do enum recebido como parâmetro.


Herança
           A herança, juntamente com o encapsulamento, polimorfismo e abstração, é uma das quatro principais características (ou pilares) da programação orientada a objeto. A herança permite que você crie novas classes para reutilizar, estender e modificar o comportamento que está definido nas outras classes. A classe cujos membros são herdados é chamada de classe base, e a classe que herda a esses membros é chamada de classe derivada. Uma classe derivada pode ter apenas uma classe base direta. No entanto, a herança é transitiva se ClassC é derivada da ClassB e ClassB é derivada da ClassA, ClassC herda os membros declarados em ClassB e ClassA.

Conceitualmente, uma classe derivada é uma especialização da classe base. Por exemplo, se você tiver uma classe base Animal, você pode ter uma classe derivada que é denominada “Mamíferos” e outra classe derivada que é denominada “Répteis”. Tanto os mamíferos quanto répteis são animais, mas cada classe derivada representa especializações diferentes da classe base.

Quando você definir uma classe para derivar de outra classe, a classe derivada implicitamente obtém todos os membros da classe base, exceto para os construtores e destrutores. A classe derivada, assim, pode reutilizar o código da classe base sem ter que rescrever. Na classe derivada, você pode adicionar mais membros. Dessa forma, a classe derivada estende a funcionalidade da classe base.

Em C# para que uma classe herde de outra deve ser adicionado após o nome da mesma “:” seguido do nome da classe base.
Exemplo abaixo.
class Animais
{
//Definição
}
class Mamiferos : Animais
{
//Definição
}
Nesse caso mamíferos passa a ser um animal e possuir todos os elementos da classe base que as restrições de visibilidade permitam.


Classe e métodos estáticos
           Uma classe estática é basicamente a mesma coisa que uma classe não estática, mas há uma diferença: uma classe estática não pode ser instanciada. Em outras palavras, você não pode usar a Palavra-chave new para criar uma variável do tipo da classe. Como não há nenhuma variável de instância, você acessa os membros de uma classe estática usando o nome da classe propriamente dito. Por exemplo, se você tiver uma classe estática denominada UtilityClass contendo um método público chamado MethodA, você chama o método conforme o exemplo abaixo:

UtilityClass.MethodA();

Uma classe estática pode ser usada como um recipiente conveniente para conjuntos de métodos que só operam nos parâmetros de entrada e não precisará obter ou definir quaisquer campos internos de instância. Por exemplo, a biblioteca de classes do .NET Framework contém a classe estática System.Math que contém métodos que executam operações matemáticas, sem a necessidade de armazenar ou recuperar dados exclusivos de uma determinada instância da classe Math. Ou seja, basta utilizar os membros da classe especificando o nome da classe e o nome do método, conforme mostrado no exemplo a seguir.
double dub = -3.14;
Console.WriteLine(Math.Abs(dub));
Console.WriteLine(Math.Floor(dub));
Console.WriteLine(Math.Round(Math.Abs(dub)));
// Output:
// 3.14
// -4
// 3

Uma classe estática não pode conter variáveis de instancia nem métodos não estáticos. Sintaxe para declaração de uma classe estática.
[Modificador de visibilidade] static class [Nome da classe]
{
//Definição
}
Exemplo:
public static class Matematica
{
//Definição
}
61 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
Uma classe não estática também pode conter métodos estáticos contanto que não acessem variáveis de instancia nem método não estáticos. A sintaxe para criação de um método estático é a mesma de um método não estático a diferença é a adição da palavra-chave “static” antes do tipo de retorno do método. Exemplo abaixo:
public static int Soma(int n1,int n2)
{
//Definição
}

Conversões
           Em C# com algumas exceções todas as conversões devem ser explicitas. Quase todos os tipo elementares oferecem métodos para conversão o Parse e o TryParse. Vamos realizar conversões para os tipos mais comuns.

//string para inteiro
string IntStr = "1";
//Só devemos usar o parse se tivermos certeza que o valor da string representa um número inteiro.
//Pois se não representar uma exceção será lançada.
int Inteiro = int.Parse(IntStr);
//Quando não temos certeza se o valor da string é um inteiro é melhor utilizar o TryParse.
//Retorna um booleano indicando se a conversão foi um sucesso.
bool Sucesso = int.TryParse(IntStr,out Inteiro);
//string para double
string DoubStr = "1,1";
double db = double.Parse(DoubStr);
Sucesso = double.TryParse(DoubStr, out db);
//string para float
string FloatStr = "1,1";
float fl = float.Parse(FloatStr);
Sucesso = float.TryParse(FloatStr, out fl);
//string para decimal
string decStr = "1,1";
decimal dc = decimal.Parse(decStr);
Sucesso = decimal.TryParse(decStr, out dc);
//string para DateTime
string DtStr = "10/01/2011";
DateTime dt = DateTime.Parse(DtStr);
Sucesso = DateTime.TryParse(DtStr, out dt);

Outra forma de conversão é a conhecida como “cast” ele é usado para converter um tipo da classe base para qualquer tipo derivado, o tipo object, por exemplo, pode ser “castado” para qualquer outro tipo em C# pois todos derivam dele. Mas atenção se o tipo que estiver na variável não for o mesmo que estamos tentando converter, uma exceção será lançada, a sintaxe do cast é a seguinte:

([nome do tipo)[nome da variável];
Exemplo
object val = 1;
int intval = (int)val;
//A linha abaixo causa uma exceção.
string strval = (string)val;

Interfaces
           A interface é uma espécie de contrato sobre as funcionalidades que os objetos que derivados dela devem ter. Ela não apresenta a implementação das funcionalidades apenas as assinaturas, mas garante que as classe derivadas as implementarão. A sintaxe para criação de interfaces é a seguinte:
[Modificador de visibilidade] interface [Nome da interface]{
//Definição
}
Nas interfaces definimos apenas assinaturas de métodos que os tipos derivados deverão ter, não precisamos definir o modificador de visibilidade, pois se está na interface o método deve ter acessibilidade irrestrita.
62 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
Exemplo
public interface IAnimais {
void Repirar();
string GetNome();
void SetNome(string Nome);
}
Classe derivada
public class Mamiferos : IAnimais {
public void Repirar()
{
throw new NotImplementedException();
}
public string GetNome()
{
throw new NotImplementedException();
}
public void SetNome(string Nome)
{
throw new NotImplementedException();
}
}

Retirado da Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#

Vinicius Vieira

email:  viiniciussjv@gmail.com