Introdução aos C # Genéricos
Então, qual é o conceito de genéricos em c #? Em palavras simples, é o conceito de definição de classes, interfaces, métodos, delegados, propriedades, etc. independentes do tipo. Isso significa que você pode definir uma classe ou corpo genérico do método e fornecer o tipo real durante a chamada.
Assim, os genéricos são como modelos de código. Eles permitem que você escreva um bloco de código com segurança de tipo sem se referir a nenhum tipo de dados específico. O tipo do seu código é determinado no tempo de compilação durante a chamada de chamada para sua classe ou método.
Sintaxe de genéricos em c #
Vejamos a sintaxe de uma declaração genérica em C #. É uma sintaxe muito simples.
Como prática comum, a letra 'T', maiúscula e entre colchetes angulares, denota a declaração de um código genérico em C #. Mas, este não é o mandato. Qualquer letra maiúscula entre colchetes angulares pode ser usada para indicar um código genérico.
Declarando uma classe genérica:
public class MyGenericClass
Instanciando uma classe genérica:
MyGenericClass = new MyGenericClass();
Declarando uma classe derivada genérica:
public class MyGenericDerivedClass : MyGenericBaseClass
Declarando um método genérico:
public T MyGenericMethod(T item);
Como funcionam os genéricos em c #?
Quando você declara um código genérico em C #, o compilador produz um modelo equivalente a esse código. Este modelo é verificado para todos os erros de compilação, exceto a segurança de tipo. A próxima etapa ocorre quando o código genérico é chamado ou chamado em outra parte do programa. No momento da chamada, você especifica o tipo com o qual seu código genérico seria compilado. Quando o compilador atinge o ponto de chamada, ele insere o tipo especificado no modelo compilado anteriormente. Isso é recompilado para verificar a segurança do tipo. Depois de aprovado, o código está pronto para execução.
Veríamos o código compilado nos exemplos abaixo para entender melhor os modelos genéricos.
Exemplo de genéricos em c #
Abaixo estão os diferentes exemplos de C # Generics:
Genéricos com classe
Código:
using System;
using System.Collections.Generic;
public class GenericClass
(
List genericList;
public GenericClass()
(
genericList = new List();
)
public void AddToList(T item)
(
genericList.Add(item);
)
public void DisplayList()
(
foreach (var ele in genericList)
(
Console.Write("(0)\t", ele);
)
)
)
public class Program
(
public static void Main()
(
GenericClass intGenericObj = new GenericClass();
GenericClass stringGenericObj = new GenericClass();
intGenericObj.AddToList(28);
intGenericObj.AddToList(999);
intGenericObj.AddToList(0);
intGenericObj.AddToList(-123);
intGenericObj.AddToList(100);
stringGenericObj.AddToList("Hello");
stringGenericObj.AddToList("Bonjour");
stringGenericObj.AddToList("Ola");
stringGenericObj.AddToList("Ciao");
stringGenericObj.AddToList("Hallo");
intGenericObj.DisplayList();
Console.WriteLine("\n");
stringGenericObj.DisplayList();
))
Resultado:
O mesmo código também pode ser reescrito como abaixo. Isso ilustra o poder de definir uma classe genérica que pode ser tornada segura para vários tipos em um único objeto.
using System;
using System.Collections.Generic;
public class GenericClass
(
List genericList1;
List genericList2;
public GenericClass()
(
genericList1 = new List();
genericList2 = new List();
)
public void AddToList(T item1, U item2)
(
genericList1.Add(item1);
genericList2.Add(item2);
)
public void DisplayList()
(
foreach (var ele in this.genericList1)
(
Console.Write("(0)\t", ele);
)
Console.WriteLine("\n");
foreach (var ele in this.genericList2)
(
Console.Write("(0)\t", ele);
)
)
)
public class Program
(
public static void Main()
(
GenericClass genericObj = new GenericClass();
genericObj.AddToList(28, "Hello");
genericObj.AddToList(999, "Bonjour");
genericObj.AddToList(0, "Ola");
genericObj.AddToList(-123, "Ciao");
genericObj.AddToList(100, "Hallo");
genericObj.DisplayList();
)
)
Resultado:
Código compilado:
Para ter uma perspectiva de como o tipo de dados é resolvido em genéricos, vejamos o código compilado gerado quando instanciamos a classe com tipos inteiro e string no exemplo acima.
using System;
using System.Collections.Generic;
public class GenericClass
(
List genericList1;
List genericList2;
public GenericClass()
(
genericList1 = new List();
genericList2 = new List();
)
public void AddToList(int item1, string item2)
(
genericList1.Add(item1);
genericList2.Add(item2);
)
public void DisplayList()
(
foreach (var ele in this.genericList1)
(
Console.Write("(0)\t", ele);
)
Console.WriteLine("\n");
foreach (var ele in this.genericList2)
(
Console.Write("(0)\t", ele);
)
)
)
public class Program
(
public static void Main()
(
GenericClass genericObj = new GenericClass();
genericObj.AddToList(28, "Hello");
genericObj.AddToList(999, "Bonjour");
genericObj.AddToList(0, "Ola");
genericObj.AddToList(-123, "Ciao");
genericObj.AddToList(100, "Hallo");
genericObj.DisplayList();
)
)
Genéricos com método
Código:
using System;
using System.Collections.Generic;
public class Program
(
public static void Main()
(
int() intArr = (12, 23, 43, 94, 35);
double() doubleArr = (12.3, 45.6, 98.7, 1.45, 82.653);
string() strArr = ("Hello", "Bonjour", "Ola", "Ciao", "Hallo");
Console.WriteLine("The largest integer in the array is (0)", findMax(intArr));
Console.WriteLine("The largest floating-point number in the array is (0)", findMax(doubleArr));
Console.WriteLine("The largest string in the array is (0)", findMax(strArr));
)
static T findMax(T() items)
where T : IComparable
(
T max = items(0);
int position = 0;
for (int i = 1; i < items.Length; i++)
(
if (items(i).CompareTo(max) > 0)
(
max = items(i);
position = i;
)
)
return max;
)
)
Resultado:
O espaço de nome System.Collections.Generic
O espaço para nome System.Collections.Generic em C # contém interfaces e classes que definem as coleções genéricas. Eles permitem que os programadores criem coleções genéricas com melhor desempenho e tipos tão fortes quanto as coleções não genéricas.
Este espaço para nome contém Listas, Dicionários, Listas Vinculadas, Hashes, Pares de Chave-Valor, Pilhas, etc., todos de natureza genérica. Os programadores podem implementá-los em seu código.
Importância dos genéricos de C #
Abaixo está a importância dos genéricos de C # da seguinte maneira:
- Os genéricos permitem a reutilização de código: o princípio fundamental de uma boa programação. Você não precisa escrever o mesmo código para cada tipo de dados esperado. Você simplesmente define um código independente de tipo e diz ao compilador que o tipo de dados real seria fornecido no momento da chamada do código.
- Evitar o custo do boxe e da retirada da boxe: é claro, o uso de genéricos pode ser ignorado por meio da classe de objeto. Os dois pedaços de código abaixo são equivalentes em suas tarefas.
Código genérico: public T MyFunc (item T);
Código não genérico: objeto público MyFunc (item de objeto)
A classe de objeto substitui todas as classes e, portanto, o código não genérico acima também pode ser usado para gerar modelos de código independentes de tipo.
Mas há uma enorme diferença de desempenho entre os dois códigos. O uso da classe de objetos incorre em um custo adicional de boxe e unboxing dos tipos de dados. Os genéricos eliminam isso e, portanto, têm melhor desempenho.
Conclusão
Assim, vimos como os genéricos são um recurso de programação que você deve aprender. Este é um conceito altamente útil, não apenas em C #, mas na maioria das linguagens de programação modernas.
Além disso, é altamente recomendável aprender sobre o espaço para nome System.Collections.Generic em C #. Além disso, para entender o desempenho dos genéricos, mergulhe profundamente em como o boxe e o unboxing afetam a memória e o tempo de execução.
Artigos recomendados
Este é um guia para C # Generics. Aqui discutimos a importância e como os genéricos funcionam em C # junto com diferentes exemplos e implementação de código. Você também pode consultar nossos outros artigos sugeridos para saber mais -
- Comparação cara a cara de C # ou operador
- Sobrecarga e substituição em Java
- O que é o uso de sobrecarga de método?
- Como a classe selada funciona em c #?
- Tipos e manipulação de erros em JavaScript
- Coleções PL / SQL | Sintaxe, Tipos, Exceções