Generics em C#

Indexador é um membro de uma classe que permite a um objeto ou estrutura ser indexado como se fosse um array. Neste post veja generics em C#.

Para que isso ocorra, os parâmetros, que na verdade são tipos, são declarados como tipos genéricos, a serem substituídos posteriormente por tipos reais.

Como os parâmetros são tipos, Generics quer dizer tipos parametrizados ou, ainda, a criação de código que seja independente de tipos.

Métodos genéricos

Método genérico é aquele que tem um tipo genérico a ser substituído por um tipo específico, por exemplo, int, no momento da chamada a este método.

O uso de métodos genéricos é indicado quando um método precisa manipular tipos diferentes.

Suponha que determinado método precisa manipular parâmetros do tipo float, mas em seguida verifica-se que precisará manipular parâmetros do tipo int e talvez até do tipo string.

Sem os métodos genéricos, seriam necessários três métodos, um para cada tipo de parâmetro. Com os métodos genéricos, apenas um será necessário. Veja:

class Teste {


//método genérico
public static void Exibe(T[] array, int qtde) {

   for(int i=0; i < qtde; i++) {
     Console.Write(array[i] + "");
     Console.WriteLine();
   }
}

class Principal	{

 public static void main() {

   Console.Clear();

   //arrays de vários tipos
   int[] pares = {2, 4, 6, 8, 10};
   char[] letras = {'a', 'b', 'c', 'd', 'e');
   string[] meses = {"Março", "Maio", "Junho", "Dezembro");		
   Console.Write("Array de inteiros: ");

   //chama o método Exibe() com um array de inteiros
   Teste.Exibe(pares, 4);
   Console.Write("Array de caracteres: ");

   //chama o método Exibe() com um array de caracteres
   Teste.Exibe(letras, 3);
   Console.Write("Array de strings: ");

   //chama o método Exibe() com um array de strings
   Teste.Exibe(meses, 2);
   Console.ReadLine();
 }
}

Classe genérica é aquela que tem um tipo genérico a ser substituído por um tipo específico, por exemplo, int, no momento da criação de seus objetos.

A sua definição é semelhante à definição de uma classe comum, acrescentando-se o tipo genérico.

O tipo genérico permite a criação de objetos que precisam operar sobre determinado tipo.

Pode ser usado para declarar campos da classe, pode ser o tipo dos parâmetros de métodos e também o tipo do valor de retorno destes.

A exemplo da herança de classes e dos métodos genéricos, as classes genéricas constituem também uma forma de reutilização de código que poupa tempo de programação. Veja:

class TesteClasseGenerica { //classe genérica
	
//campos
T valor;
int tipo;

//construtor com parâmetros
public TesteClasseGenerica(T valor1, int tipo1) {
		
   valor = valor1;
   tipo = tipo1;
}

public void Exibe() {
		
   if(tipo == 2) {
			
     Console.WriteLine("O tipo T agora é: " + typeof(T));
     Console.WriteLine(" campo valor do objeto OInt: " + valor);
     Console.WriteLine();
   } else		
	if(tipo == 2) {
				
	   Console.WriteLine("O tipo T agora é: " + typeof(T));
	   Console.WriteLine(" campo valor do objeto OChr: " + valor);
	   Console.WriteLine();
	} else {

		Console.WriteLine("O tipo T agora é: " + typeof(T));
		Console.WriteLine(" campo valor do objeto OShr: " + valor);
	}
    }
}

class Principal	{

 public static void Main() {
		
   Console.Clear();

   //cria objetos para tipos diferentes
   TesteClasseGenerica<int> Oint = new TesteClasseGenerica<int>(5, 1);
   TesteClasseGenerica<char> OChr = new TesteClasseGenerica<char>('X', 2);
   TesteClasseGenerica<string> OStr = new TesteClasseGenerica<string>(".Net", 3);
   
   // cada objeto chama o método Exibe()
   OInt.Exibe();
   OChr.Exibe();
   OStr.Exibe();
 }
}

Além de classes genéricas, é possível criar estruturas genéricas cuja sintaxe é a mesma das classes. E ainda como estas, podem ter mais de um tipo genérico.

class EstruturaGenerica {
	
  struct Teste { //estrutura genérica
		
     //membros
     T valor;
     string obj;

     //construtor do usuário
     public Teste(T valor1, string obj1) {
			
        valor = valor1;
	obj = obj1;
     }

     public void Exibe() {
			
         Console.WriteLine("O tipo T agora é: " + typeof(T));
         Console.WriteLine("Campo valor do objeto " + obj + ": " + valor);
	 Console.WriteLine();
     }
   }

struct Principal { // ou class Principal
		
    public static vois Main() {
			
       Console.Clear();

       //cria objetos para tipos diferentes
       Teste<int> Oint = new Teste<int>(5, "Oint");
       Teste<char> OChr = new Teste<char>('X', "OChr");
       Teste<string> OStr = new Teste<string>(".Net", "OStr");
 
       //cada objeto chama o método Exibe()
       OInt.Exibe();
       OChr.Exibe();
       OStr.Exibe();
     }
 }
	

Dúvidas ou sugestões? Deixem nos comentários! Para mais dicas, acesse o nosso canal no YouTube:
 https://youtube.com/criandobits

Tags: csharp | generics