Introdução aos genéricos (Guia de Programação em C#)Introduction to Generics (C# Programming Guide)

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");
    }
}

Consulte tambémSee Also