Visão geral de tipos genéricos
Desenvolvedores usam genéricos o tempo todo no .NET, seja implícita ou explicitamente. Ao usar o LINQ no .NET, você já percebeu que você está trabalhando com IEnumerable<T>? Ou, no caso de você já ter visto um exemplo de um "repositório genérico" online para conversar com bancos de dados usando o Entity Framework, você já viu que a maioria dos métodos retornam IQueryable<T>? Talvez você tenha se perguntado o que é o T nesses exemplos e por que ele está lá.
Introduzidos pela primeira vez no .NET Framework 2.0, os genéricos são essencialmente um "modelo de código" que permite aos desenvolvedores definir estruturas de dados fortemente tipadas sem se comprometer com um tipo de dados real. Por exemplo, List<T> é uma coleção de genéricos que pode ser declarada e usada com qualquer tipo, como List<int>, List<string> ou List<Person>.
Para entender por que os genéricos são úteis, vamos dar uma olhada em uma classe específica antes e depois adicionar os genéricos: ArrayList. No .NET Framework 1.0, os elementos ArrayList eram do tipo Object. Qualquer elemento adicionado à coleção foi silenciosamente convertido em um Object. O mesmo aconteceria ao ler os elementos da lista. Esse processo é conhecido como conversão boxing e unboxing e afeta o desempenho. Além do desempenho, no entanto, não há como determinar o tipo de dados na lista em tempo de compilação, o que torna algum código frágil. Genéricos resolvem esse problema definindo o tipo de dados que cada instância de lista conterá. Resumindo, você só pode adicionar inteiros a List<int> e só pode adicionar Pessoas a List<Person>.
Genéricos também estão disponíveis em tempo de execução. O runtime sabe que tipo de estrutura de dados você está usando e pode armazená-la na memória com mais eficiência.
O exemplo a seguir é um pequeno programa que ilustra a eficiência de saber o tipo da estrutura de dados em tempo de execução:
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
namespace GenericsExample {
class Program {
static void Main(string[] args) {
//generic list
List<int> ListGeneric = new List<int> { 5, 9, 1, 4 };
//non-generic list
ArrayList ListNonGeneric = new ArrayList { 5, 9, 1, 4 };
// timer for generic list sort
Stopwatch s = Stopwatch.StartNew();
ListGeneric.Sort();
s.Stop();
Console.WriteLine($"Generic Sort: {ListGeneric} \n Time taken: {s.Elapsed.TotalMilliseconds}ms");
//timer for non-generic list sort
Stopwatch s2 = Stopwatch.StartNew();
ListNonGeneric.Sort();
s2.Stop();
Console.WriteLine($"Non-Generic Sort: {ListNonGeneric} \n Time taken: {s2.Elapsed.TotalMilliseconds}ms");
Console.ReadLine();
}
}
}
Este programa produz uma saída semelhante à seguinte:
Generic Sort: System.Collections.Generic.List`1[System.Int32]
Time taken: 0.0034ms
Non-Generic Sort: System.Collections.ArrayList
Time taken: 0.2592ms
A primeira coisa que você pode observar aqui é que classificar a lista genérica é significativamente mais rápido do que classificar a lista não genérica. Você também observará que o tipo de lista genérico é distinto ([System.Int32]) enquanto o tipo da lista não genérico é generalizado. Como o runtime sabe que o genérico List<int> é do tipo Int32, ele pode armazenar elementos de lista em uma matriz de inteiros subjacente na memória, enquanto o ArrayList não genérico tem que converter cada elemento da lista em um objeto. Como este exemplo mostra, as conversões extras levam tempo e reduzem a velocidade da classificação da lista.
Uma vantagem adicional de o runtime saber o tipo de seu genérico é uma melhor experiência de depuração. Quando você está depurando um genérico em C#, você sabe que tipo de cada elemento está na sua estrutura de dados. Sem os genéricos, você não faria ideia de qual o tipo de cada elemento.
