C# - Genéricos

Genéricos permitem definir a especificação do tipo de dados dos elementos de programação em uma classe ou método, até que seja realmente utilizado no programa. Em outras palavras, os genéricos permitem que você escreva uma classe ou método que pode funcionar com qualquer tipo de dados.

Você escreve as especificações para a classe ou método, com parâmetros substitutos para tipos de dados. Quando o compilador encontra um construtor para a classe ou uma chamada de função para o método, ele gera código para manipular o tipo de dados específico. Um exemplo simples ajudaria a entender o conceito -
Demonstração ao vivo

using System;
using System.Collections.Generic;

namespace GenericApplication {
   public class MyGenericArray<T> {
      private T[] array;
      
      public MyGenericArray(int size) {
         array = new T[size + 1];
      }
      public T getItem(int index) {
         return array[index];
      }
      public void setItem(int index, T value) {
         array[index] = value;
      }
   }
   class Tester {
      static void Main(string[] args) {
         
         //declaring an int array
         MyGenericArray<int> intArray = new MyGenericArray<int>(5);
         
         //setting values
         for (int c = 0; c < 5; c++) {
            intArray.setItem(c, c*5);
         }
         
         //retrieving the values
         for (int c = 0; c < 5; c++) {
            Console.Write(intArray.getItem(c) + " ");
         }
         
         Console.WriteLine();
         
         //declaring a character array
         MyGenericArray<char> charArray = new MyGenericArray<char>(5);
         
         //setting values
         for (int c = 0; c < 5; c++) {
            charArray.setItem(c, (char)(c+97));
         }
         
         //retrieving the values
         for (int c = 0; c< 5; c++) {
            Console.Write(charArray.getItem(c) + " ");
         }
         Console.WriteLine();
         
         Console.ReadKey();
      }
   }
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

0 5 10 15 20
a b c d e

Recursos dos genéricos

Genéricos é uma técnica que enriquece seus programas das seguintes maneiras −

• 
  Ele ajuda você a maximizar a reutilização de código, segurança de tipo e desempenho.
  
• 
  Você pode criar classes de coleção genéricas. A biblioteca de classes do .NET Framework contém várias novas classes de coleção genéricas no System.Collections.Generic namespace. Você pode usar essas classes de coleção genéricas em vez das classes de coleção em System.Collections namespace.
  
• 
  Você pode criar suas próprias interfaces, classes, métodos, eventos e delegados genéricos.
  
• 
  Você pode criar classes genéricas restritas para permitir o acesso a métodos em tipos de dados específicos.
  
• 
  Você pode obter informações sobre os tipos usados ​​em um tipo de dados genérico em tempo de execução por meio de reflexão.
  

Métodos genéricos

No exemplo anterior, usamos uma classe genérica; podemos declarar um método genérico com um parâmetro de tipo. O programa a seguir ilustra o conceito -
Demonstração ao vivo

using System;
using System.Collections.Generic;

namespace GenericMethodAppl {
   class Program {
      static void Swap<T>(ref T lhs, ref T rhs) {
         T temp;
         temp = lhs;
         lhs = rhs;
         rhs = temp;
      }
      static void Main(string[] args) {
         int a, b;
         char c, d;
         a = 10;
         b = 20;
         c = 'I';
         d = 'V';
         
         //display values before swap:
         Console.WriteLine("Int values before calling swap:");
         Console.WriteLine("a = {0}, b = {1}", a, b);
         Console.WriteLine("Char values before calling swap:");
         Console.WriteLine("c = {0}, d = {1}", c, d);
         
         //call swap
         Swap<int>(ref a, ref b);
         Swap<char>(ref c, ref d);
         
         //display values after swap:
         Console.WriteLine("Int values after calling swap:");
         Console.WriteLine("a = {0}, b = {1}", a, b);
         Console.WriteLine("Char values after calling swap:");
         Console.WriteLine("c = {0}, d = {1}", c, d);
         
         Console.ReadKey();
      }
   }
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

Int values before calling swap:
a = 10, b = 20
Char values before calling swap:
c = I, d = V
Int values after calling swap:
a = 20, b = 10
Char values after calling swap:
c = V, d = I

Delegados genéricos

Você pode definir um delegado genérico com parâmetros de tipo. Por exemplo -

delegate T NumberChanger<T>(T n);

O exemplo a seguir mostra o uso deste delegado -
Demonstração ao vivo

using System;
using System.Collections.Generic;

delegate T NumberChanger<T>(T n);
namespace GenericDelegateAppl {
   class TestDelegate {
      static int num = 10;
      
      public static int AddNum(int p) {
         num += p;
         return num;
      }
      public static int MultNum(int q) {
         num *= q;
         return num;
      }
      public static int getNum() {
         return num;
      }
      static void Main(string[] args) {
         //create delegate instances
         NumberChanger<int> nc1 = new NumberChanger<int>(AddNum);
         NumberChanger<int> nc2 = new NumberChanger<int>(MultNum);
         
         //calling the methods using the delegate objects
         nc1(25);
         Console.WriteLine("Value of Num: {0}", getNum());
         
         nc2(5);
         Console.WriteLine("Value of Num: {0}", getNum());
         Console.ReadKey();
      }
   }
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

Value of Num: 35
Value of Num: 175