Arquivo da categoria: Tipos Definidos pelo Usuário

Os possíveis Tipos Definidos pelo Usuário disponibilizados pelo C#

Manipulando strings

Existem diversos métodos no próprio tipo string para sua manipulação. No entanto, as strings são imutáveis, ou seja, não podem ser alteradas uma vez criadas. Até é possível criar outra string, mas não mudá-las. Nos casos em que seria conveniente modificar a string, podemos usar a classe “StringBuilder”. Veja o exemplo a seguir:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
using System;
using System.Text;
 
public class Class1
{
      // Troca um caractere por outro dentro da string
      static void Troca(ref StringBuilder s, char Chl, char Ch2)
      {
            for(int i = 0; i < s.Length; i++)
            {
                  if (s[i] == Chl)
                        s[i] = Ch2;
            }
      }
 
      public static void Main()
      {
            // Cria a string
            StringBuilder s = new StringBuilder("Maria tinha um carneirinho");
            // Troca caracteres
            Troca(ref s, ‘ ‘, ‘_’);
            // Exibe
            Console.WriteLine(s);
      }
}

O classe string possui uma série de métodos que auxiliam na sua manipulação, entre eles:

  • Substring
  • IndexOf
  • ToUpper
  • ToLower
  • StartsWith
  • EndsWith
  • TrimStart
  • TrimEnd
  • Trim
  • PadLeft
  • PadRight
  • Join
  • Split
  • Format

Estas serão vistas mais adiante com detalhes.

Arrays

Um array reúne sob o mesmo identificador muitas variáveis do mesmo tipo, acessadas por um índice.

Todos os arrays em C# são criados dinamicamente, ou seja, em tempo de execução. O tamanho é sempre definido em tempo de execução.

A declaração de um array sempre tem “[]” depois do tipo da variável. Devemos sempre chamar new para inicializar a array. Note que o primeiro índice do array é sempre zero. Veja no exemplo abaixo um array de uma dimensão:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
 
public class Class1
{
      const int Max = 5;
 
      public static void Main()
      {
            double[] Notas = new double[Max];
            Notas[0] = 6;
            Notas[1] = 9.5;
            Notas[2] = 4.2;
            Notas[3] = 7.2;
            Notas[4] = 5.4;
            double Soma = 0;
            foreach (double Nota in Notas)
            {
                  Soma = Soma + Nota;
            }
            Console.WriteLine(Soma / Max);
      }
}

Um array de várias dimensões pode ser declarado colocando vírgulas dentro dos colchetes. Você pode definir um array “dentado”, um array de arrays. A diferença no array “dentado” é que cada linha pode ter um tamanho diferente. Veja alguns exemplos:

1
2
3
4
5
6
7
...
int[] al;   // array de inteiro de uma dimensão
int[,] a2;  // array de inteiro de duas dimensões
int[,,] a3; // array de inteiro de três dimensões
int[][] j2; // array "dentado" (array de array)
int[][][] j3;     // array de array de array
...

Todo array deve ser inicializado. Você pode simplesmente especificar o tamanho ou ainda atribuir valores:

1
2
3
4
5
6
7
8
9
10
11
...
int[] al = new int[] {1, 2, 3};
int[,] a2 = new int[,] {{1, 2, 3}, {4, 5, 6}};
int[,,] a3 = new int[10, 20, 30];
int[] [] j2 = new int[3] [];
j2[0] = new int[] {1, 2, 3};
j2[1] = new int[] {1, 2, 3, 4, 5, 6};
j2[2] = new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9};
int[] al = new int[] {1, 2, 3};
int[] al = {1, 2, 3};
...

A faixa dos arrays é verificada em tempo de execução. Se você indexar o array com um valor fora de faixa, uma exception é gerada.

Garbage Collector

O gerenciamento de memória é totalmente controlado pelo sistema de execução do NET.

O seu programa aloca memória indiretamente ao criar variáveis com “new”, mas nunca a libera diretamente. O sistema de runtime automaticamente libera a memória usada pelas variáveis que não são mais referenciadas, em um processo chamado “garbage collection”.

Este é um ponto polêmico: não existe dúvida que um programador pode gerenciar memória melhor. O problema é que os erros causados por mau gerenciamento de memória são muito comuns. É melhor deixar o computador fazer um serviço não ótimo, mas correto do que deixar os programadores tentarem fazer um serviço ótimo e errarem. É um caso típico do “ótimo brigando com o bom”.

Este esquema facilita bastante a programação e elimina uma grande fonte de erros.

Existem formas de manipular o Garbage Collector, forçando a “coleta” por exemplo. Porém, isso não é feito com frequência, além de não ser condiderado uma boa prática, já que não há como garantir quando a coleta será feita exatamente.

Não é preciso ir muito longe para deduzir que este mecanismo é herdado da Java Virtual Machine. Neste ponto, não é necessário entrar em detalhes sobre como é o funcionamento do Garbage Collector. Basta saber que a liberação de memória na maioria dos casos deixa de ser uma preocupação do programador.

Liberação de recursos

Caso a classe utilize algum recurso externo como conexão de banco de dados, “handle” de arquivo etc, pode ser necessário libera-lo através da chamada de algum método específico, tipicamente chamado “Close”.

Interface

Tipo definido pelo usuário. Uma interface é uma espécie de classe, mas contém apenas os “protótipos” dos métodos, sem a sua implementação. Corresponde no C++ a uma classe abstrata com todos os métodos “virtuais puros”. Uma classe, além de ser derivada de outra, pode implementar várias interfaces.

Abaixo pode-se ver um exemplo de declaração de interface e sua aplicação em uma classe:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
interface IMinhaInterface
{
    void MeuMetodo();
}
 
class MinhaClasse : IMinhaInterface
{
    // Implementação explícita do membro da interface herdada: 
    void IMinhaInterface.Metodo()
    {
        // Corpo do método.
    }
 
    static void Main()
    {
        // Declara uma instância da classe baseada na interface.
        IMinhaInterface obj = new MinhaClasse();
 
        // Invoca o método.
        obj.MeuMetodo();
    }
}

Veja maiores detalhes no capítulo sobre Orientação a Objetos.

Class (por referência)

Permite declarar classes, de maneira semelhante ao C++. As principais diferenças são:

  • Não é preciso seguir uma ordem de declaração, podendo declarar variáveis por exemplo, em qualquer parte do corpo da classe
  • Não é permitida a herança múltipla de classes

Um exemplo simples de uma classe em C# pode ser visto abaixo:

1
2
3
4
class MinhaClasse
{
    // Corpo da classe (Métodos, Variáveis, Propriedades, sub classes)
}

Veja maiores detalhes no capítulo sobre Orientação a Objetos que será abordado posteriormente neste curso.

Struct (por valor)

Permite declarar tipos que contém vários valores, identificados por um nome. Semelhante a struct do C. Exemplo:

1
2
3
4
5
6
7
8
9
public struct Point
{
    public int x, y;
    public Point(int pl, int p2)
    {
          x = pl;
          y = p2;
    }
}

As structs possuem algumas características em comum com as classes:

  • Podem ter métodos.
  • Podem ter construtores.

Entretanto, existem diferenças em relação às classes:

  • Elas são tipos por valor enquanto classes são tipos por referência
  • Não podemos declarar um construtor que não aceite argumentos.
  • Podemos atribuir à variável “this”.
  • Não suportam herança; elas são implicitamente “sealed”.

As structs fornecem uma alternativa mais “leve e barata” às classes, onde o custo do uso das classes (alocação dinâmica de memória, métodos virtuais e uso de ponteiros) seria muito caro. Por exemplo, um ponto (coordenada X, Y).

Enum (por valor)

Permite declarar uma seqüência de identificadores associados, mas incompatíveis com inteiros e com outras enumerações.

Exemplo:

1
2
3
4
5
6
7
8
9
10
enum Days
{
    Sun,
    Mon,
    Tue,
    Wed,
    Thu,
    Fri,
    Sat
};

Os itens são obrigatoriamente separados por vírgula. Na omissão de valores, eles seguirão a sequência da declaração dos itens. A sentença acima equivale a:

1
2
3
4
5
6
7
8
9
10
enum Days
{
    Sun = 1,
    Mon = 2,
    Tue = 3,
    Wed = 4,
    Thu = 5,
    Fri = 6,
    Sat = 7
};

Enums aceitam modificadores e não precisam obrigatoriamente estar em uma classe ou arquivo separado. Seu valor pode ser implicitamente convertido para um int e sua presentação textual pode ser obtida através do método ToString(). Por exemplo:

1
2
3
4
...
int i = Days.Wed; // i = 4
string s = Day.Fri.ToString(); // s = "Fri"
...

Tipos Definifidos pelo Usuário

Com o C# você pode declarar novos tipos, de maneira semelhante ao C++ e Pascal. Os novos tipos são usados em qualquer situação que normalmente você usaria um tipo.

Diversos mecanismos são disponibilizados para criação de tipos personalizados, desde os tradicionais já disponibilizados pelo natural suporte à orientação a objetos, até mecanismos particulares da linguagem, como:

  • Enum
  • Struct
  • Class
  • Interface
  • Arraylists

Todos serão vistos com mais detalhes no decorrer do curso.