Genéricos (Guia de Programação em C#)Generics (C# Programming Guide)

Genéricos foram adicionados à versão 2.0 da linguagem C# e o common language runtime (CLR).Generics were added to version 2.0 of the C# language and the common language runtime (CLR). Genéricos apresentam ao .NET Framework o conceito de parâmetros de tipo, que possibilitam a criação de classes e métodos que adiam a especificação de um ou mais tipos até que a classe ou método seja declarado e instanciado pelo código do cliente.Generics introduce to the .NET Framework the concept of type parameters, which make it possible to design classes and methods that defer the specification of one or more types until the class or method is declared and instantiated by client code. 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 corre o risco de conversões de tempo de execução ou operações de conversão boxing, conforme mostrado aqui:For example, by using a generic type parameter T you can write a single class that other client code can use without incurring the cost or risk of runtime casts or boxing operations, as shown here:

// Declare the generic class.
public class GenericList<T>
{
    public void Add(T input) { }
}
class TestGenericList
{
    private class ExampleClass { }
    static void Main()
    {
        // Declare a list of type int.
        GenericList<int> list1 = new GenericList<int>();
        list1.Add(1);

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

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

As classes e métodos genéricos combinam a capacidade de reutilização, a segurança de tipos e a eficiência de uma maneira que suas contrapartes não genéricas não conseguem.Generic classes and methods combine reusability, type safety and efficiency in a way that their non-generic counterparts cannot. Os genéricos são usados com mais frequência com coleções e com os métodos que operam nelas.Generics are most frequently used with collections and the methods that operate on them. A versão 2.0 da biblioteca de classes do .NET Framework fornece um novo namespace, System.Collections.Generic, que contém várias classes de coleção novas com base em genéricos.Version 2.0 of the .NET Framework class library provides a new namespace, System.Collections.Generic, which contains several new generic-based collection classes. É recomendável que todos os aplicativos que se destinam ao .NET Framework 2.0 e posterior usem as novas classes de coleção genéricas em vez das homólogas não genéricas mais antigas, como a ArrayList.It is recommended that all applications that target the .NET Framework 2.0 and later use the new generic collection classes instead of the older non-generic counterparts such as ArrayList. Para saber mais, confira Genéricos no .NET.For more information, see Generics in .NET.

É claro que você também pode criar tipos e métodos genéricos personalizados para fornecer suas próprias soluções e padrões de design generalizados que sejam fortemente tipados e eficientes.Of course, you can also create custom generic types and methods to provide your own generalized solutions and design patterns that are type-safe and efficient. O exemplo de código a seguir mostra uma classe de lista vinculada genérica simples para fins de demonstração.The following code example shows a simple generic linked-list class for demonstration purposes. (Na maioria dos casos, você deve usar a classe List<T>, fornecida pela biblioteca de classes .NET Framework, em vez de criar a sua própria classe). O parâmetro de tipo T é usado em vários locais em que um tipo concreto normalmente seria usado para indicar o tipo do item armazenado na lista.(In most cases, you should use the List<T> class provided by the .NET Framework class library instead of creating your own.) The type parameter T is used in several locations where a concrete type would ordinarily be used to indicate the type of the item stored in the list. Ele é usado das seguintes maneiras:It is used in the following ways:

  • Como o tipo de um parâmetro de método no método AddHead.As the type of a method parameter in the AddHead method.

  • Como o tipo de retorno da propriedade Data na classe Node aninhada.As the return type of the Data property in the nested Node class.

  • Como o tipo de data do membro particular na classe aninhada.As the type of the private member data in the nested class.

Observe que T está disponível para a classe Node aninhada.Note that T is available to the nested Node class. Quando GenericList<T> é instanciada com um tipo concreto, por exemplo como um GenericList<int>, cada ocorrência de T será substituída por int.When GenericList<T> is instantiated with a concrete type, for example as a GenericList<int>, each occurrence of T will be replaced with int.

// type parameter T in angle brackets
public class GenericList<T> 
{
    // The nested class is also generic on T.
    private class Node
    {
        // T used in non-generic constructor.
        public Node(T t)
        {
            next = null;
            data = t;
        }

        private Node next;
        public Node Next
        {
            get { return next; }
            set { next = value; }
        }
        
        // T as private member data type.
        private T data;

        // T as return type of property.
        public T Data  
        {
            get { return data; }
            set { data = value; }
        }
    }

    private Node head;
    
    // constructor
    public GenericList() 
    {
        head = null;
    }

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

    public IEnumerator<T> GetEnumerator()
    {
        Node current = head;

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

O exemplo de código a seguir mostra como o código cliente usa a classe GenericList<T> genérica para criar uma lista de inteiros.The following code example shows how client code uses the generic GenericList<T> class to create a list of integers. Ao simplesmente alterar o argumento de tipo, o código a seguir poderia facilmente ser modificado para criar listas de cadeias de caracteres ou qualquer outro tipo personalizado:Simply by changing the type argument, the following code could easily be modified to create lists of strings or any other custom type:

class TestGenericList
{
    static void Main()
    {
        // int is the type argument
        GenericList<int> list = new GenericList<int>();

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

        foreach (int i in list)
        {
            System.Console.Write(i + " ");
        }
        System.Console.WriteLine("\nDone");
    }
}

Visão geral de genéricosGenerics Overview

  • Use tipos genéricos para maximizar a reutilização de código, o desempenho e a segurança de tipo.Use generic types to maximize code reuse, type safety, and performance.

  • O uso mais comum de genéricos é para criar classes de coleção.The most common use of generics is to create collection classes.

  • A biblioteca de classes do .NET Framework contém várias classes de coleção de genéricos novos no namespace System.Collections.Generic.The .NET Framework class library contains several new generic collection classes in the System.Collections.Generic namespace. Eles devem ser usados sempre que possível, em vez de classes como ArrayList no namespace System.Collections.These should be used whenever possible instead of classes such as ArrayList in the System.Collections namespace.

  • Você pode criar suas próprias interfaces genéricas, classes, métodos, eventos e delegados.You can create your own generic interfaces, classes, methods, events and delegates.

  • Classes genéricas podem ser restringidas para habilitar o acesso aos métodos em tipos de dados específicos.Generic classes may be constrained to enable access to methods on particular data types.

  • Informações sobre os tipos que são usados em um tipo de dados genérico podem ser obtidas no tempo de execução por meio de reflexão.Information on the types that are used in a generic data type may be obtained at run-time by using reflection.

Para saber mais:For more information:

Especificação da Linguagem C#C# Language Specification

Para obter mais informações, consulte a Especificação da linguagem C#.For more information, see the C# Language Specification.

Consulte tambémSee also