Introdução ao Generics (guia de programação C#)
Classes genéricas e métodos combinam a capacidade de reutilização, a segurança de tipos e a eficiência de forma que suas contrapartes não genéricos não podem.Genéricos são usados com mais freqüência com coleções e os métodos que operam sobre eles.Versão 2.0 do biblioteca de classes do .NET estrutura fornece um novo namespace, System.Collections.Generic, que contém várias classes de coleção genérica com novos. É recomendável que todos sistema autônomo aplicativos que se destinam a .NET Framework 2.0 e posteriores usar sistema autônomo novas classes de coleção genérica em vez dos contrapartes não genéricas mais antigas, sistema autônomo ArrayList. Para obter mais informações, consulte Generics na biblioteca de classe Framework .NET (guia de programação C#).
Obviamente, você também pode criar tipos genéricos personalizados e generalizado de métodos para fornecer suas próprias soluções e padrões de design que são seguros e eficientes.O exemplo de código a seguir mostra uma classe lista vinculada genérica simples para fins de demonstração.(Na maioria dos casos, você deve usar o List<T> classe fornecida pela biblioteca de classes do .NET estrutura em vez de criar seus próprios.) O tipo de parâmetro T é usado em vários locais onde um tipo concreto normalmente deve ser usado para indicar o tipo armazenada na lista. Ele é usado das seguintes maneiras:
sistema autônomo o tipo de um parâmetro de método no AddHead método.
sistema autônomo o tipo de retorno do método público GetNext e o Data propriedade no aninhados Node classe.
sistema autônomo o tipo dos dados membro privado de classe aninhada.
Observe que T está disponível para o aninhados Node classe. Quando GenericList<T> é instanciado com um tipo concreto, por exemplo sistema autônomo um GenericList<int>, cada ocorrência de T será substituído por 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 do cliente usa o genérico GenericList<T> classe para criar uma lista de inteiros. Simplesmente alterando o tipo de argumento, o código a seguir poderia com com facilidade ser modificado para criar listas de seqüências de caracteres ou qualquer Outros tipo personalizado:
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");
}
}