Compartilhar via

Classes e métodos genéricos

Os genéricos introduzem o conceito de parâmetros de tipo ao .NET. Genéricos possibilitam o design de classes e métodos que adiam a especificação de um ou mais parâmetros de tipo até que você use a classe ou o método em seu código. Por exemplo, ao usar um parâmetro de tipo genérico T, você pode escrever uma única classe que outro código de cliente pode usar sem incorrer o custo ou risco de conversões de runtime ou operações de conversão boxing, conforme mostrado aqui:

// Declare the generic class.
public class GenericList<T>
{
    public void Add(T item) { }
}

public class ExampleClass { }

class TestGenericList
{
    static void Main()
    {
        // Create a list of type int.
        GenericList<int> list1 = new();
        list1.Add(1);

        // Create a list of type string.
        GenericList<string> list2 = new();
        list2.Add("");

        // Create a list of type ExampleClass.
        GenericList<ExampleClass> list3 = new();
        list3.Add(new ExampleClass());
    }
}

Classes e métodos genéricos combinam reutilização, segurança de tipo e eficiência de uma maneira que seus equivalentes não genéricos não podem. Parâmetros de tipo genérico são substituídos pelos argumentos de tipo durante a compilação. No exemplo anterior, o compilador substitui T por int. Genéricos são usados mais frequentemente em coleções e nos métodos que operam sobre elas. O System.Collections.Generic namespace contém várias classes de coleção de base genérica. As coleções não genéricas, como ArrayList não são recomendadas e são mantidas apenas para fins de compatibilidade. Para saber mais, confira Genéricos no .NET.

Você também pode criar tipos e métodos genéricos personalizados para fornecer suas próprias soluções generalizadas e padrões de design que são seguros por tipo e eficientes. O exemplo de código a seguir mostra uma classe de lista vinculada genérica simples para fins de demonstração. (Na maioria dos casos, você deve usar a List<T> classe fornecida pelo .NET em vez de criar sua própria.) O parâmetro T de tipo é usado em vários locais em que um tipo concreto normalmente seria usado para indicar o tipo do item armazenado na lista:

  • Como o tipo de um parâmetro de método no método AddHead.
  • Como o tipo de retorno da propriedade Data na classe Node aninhada.
  • Como o tipo de data do membro particular na classe aninhada.

T está disponível na classe aninhada Node. Quando GenericList<T> é instanciado com um tipo concreto, por exemplo, como um GenericList<int>, cada ocorrência de T é substituída por int.

// Type parameter T in angle brackets.
public class GenericList<T>
{
    // The nested class is also generic, and
    // holds a data item of type T.
    private class Node(T t)
    {
        // T as property type.
        public T Data { get; set; } = t;

        public Node? Next { get; set; }
    }

    // First item in the linked list
    private Node? head;

    // T as parameter type.
    public void AddHead(T t)
    {
        Node n = new(t);
        n.Next = head;
        head = n;
    }

    // T in method return type.
    public IEnumerator<T> GetEnumerator()
    {
        Node? current = head;

        while (current is not null)
        {
            yield return current.Data;
            current = current.Next;
        }
    }
}

O exemplo de código a seguir mostra como o código do cliente usa a classe genérica GenericList<T> para criar uma lista de inteiros. Se você alterar o argumento de tipo, o código a seguir criará listas de cadeias de caracteres ou qualquer outro tipo personalizado:

// A generic list of int.
GenericList<int> list = new();

// Add ten int values.
for (int x = 0; x < 10; x++)
{
    list.AddHead(x);
}

// Write them to the console.
foreach (int i in list)
{
    Console.WriteLine(i);
}

Console.WriteLine("Done");

Observação

Tipos genéricos não se limitam a classes. Os exemplos anteriores usam os tipos class, mas você pode definir os tipos genéricos interface e struct, inclusive os tipos record.

Visão geral de genéricos

  • Use tipos genéricos para maximizar a reutilização, a segurança do tipo e o desempenho do código.
  • O uso mais comum de genéricos é criar classes de coleção.
  • A biblioteca de classes do .NET contém várias classes de coleção genéricas no System.Collections.Generic namespace. As coleções genéricas devem ser usadas sempre que possível, em vez de classes como ArrayList no System.Collections namespace.
  • Você pode criar suas próprias interfaces genéricas, classes, métodos, eventos e delegados.
  • Classes genéricas podem ser restritas para habilitar o acesso a métodos em determinados tipos de dados.
  • Você pode obter informações em tempo de execução sobre os tipos usados em um tipo de dados genérico usando reflexão.

Especificação da linguagem C#

Para obter mais informações, consulte a Especificação da Linguagem C# .

Consulte também