Classes genéricos (guia de programação C#)
Classes genéricas encapsulam as operações que não são específicas de um tipo de dados específico.O uso mais comum para classes genéricas é com coleções como listas vinculadas, tabelas de hash, pilhas, filas, árvores e assim por diante.sistema autônomo operações sistema autônomo adicionar e remover itens da coleção são realizadas basicamente da mesma maneira independentemente do tipo de dados armazenados.
Para a maioria dos cenários que exigem as coleções de classes, a abordagem recomendada é usar os esquemas fornecidos na biblioteca de classes do .NET estrutura.Para obter mais informações sobre como usar essas classes, consulte Generics na biblioteca de classe Framework .NET (guia de programação C#).
Normalmente, você cria classes genéricas iniciando com uma classe concreta existente e alterar tipos em parâmetros de tipo de um por vez até atingir o equilíbrio ideal de generalização e usabilidade.Ao criar suas próprias classes genéricas, considerações importantes incluem o seguinte:
Quais tipos de generalize em tipo de parâmetros.
sistema autônomo uma regra, mais tipos que você pode parametrizar, o mais flexíveis e reutilizáveis se torna seu código.No entanto, muito generalização pode criar código que é difícil para outros desenvolvedores ler ou entender.
Quais restrições, se houver, para aplicar os parâmetros de tipo (consulte Restrições em parâmetros de tipo (Guia de programação C#)).
Uma mercadoria regra é aplicar restrições máxima possíveis que ainda permitirá a você manipular tipos que deve tratar.Por exemplo, se você souber que sua classe genérica é destinado ao uso somente com tipos de referência, aplicar a restrição de classe.Que irá impedir o uso não desejado da sua classe com tipos de valor e permitirá que você use o as operador em Te verifique se há valores nulo.
Se fator comportamento genérico em classes base e subclasses.
sistema autônomo classes genéricas podem servir sistema autônomo classes base, sistema autônomo mesmas considerações de design se aplicam aqui sistema autônomo ocorre com classes não-genéricas.Consulte as regras sobre a herança de classes base genéricos neste tópico.
Se implementar um ou mais interfaces genéricas.
Por exemplo, se você estiver criando uma classe que será usada para criar itens em uma coleção com base em classes genéricas, talvez você precise implementar uma interface, sistema autônomo IComparable<T> onde T é o tipo de sua classe.
Para obter um exemplo de uma classe genérica simples, consulte Introdução ao Generics (guia de programação C#).
As regras para parâmetros de tipo e restrições têm várias implicações para o comportamento da classe genérica, especialmente sobre herança e membro acessibilidade.Antes de prosseguir, você deve compreender alguns termos.Para uma classe genérica Node<T>, código do cliente pode referenciar a classe por especificar um argumento de tipo, para criar um tipo construído fechada (Node<int>). Como alternativa, ele pode deixar o parâmetro de tipo não for especificado, por exemplo, quando você especificar uma classe base genérica, para criar um tipo em aberto construído (Node<T>). Classes genéricas podem herdar de concreto, fechado construído, ou em aberto construído classes base:
class BaseNode { }
class BaseNodeGeneric<T> { }
// concrete type
class NodeConcrete<T> : BaseNode { }
//closed constructed type
class NodeClosed<T> : BaseNodeGeneric<int> { }
//open constructed type
class NodeOpen<T> : BaseNodeGeneric<T> { }
Não-genérica em Outros classes concretas, palavras, podem herdar de classes de base construídos fechados, mas não a partir de classes construídos abertos ou parâmetros de tipo nua porque não é possível em time de execução para o código do cliente fornecer o argumento de tipo necessário para criar uma instância da classe base.
//No error
class Node1 : BaseNodeGeneric<int> { }
//Generates an error
//class Node2 : BaseNodeGeneric<T> {}
//Generates an error
//class Node3 : T {}
Clsistema autônomoses genérico que herdam a tipos abertos construídos deve fornecer argumentos de tipo de qualquer parâmetro de tipo clsistema autônomos bsistema autônomoe que não é compartilhado por herança clsistema autônomos, sistema autônomo demonstrado no código a seguir:
class BaseNodeMultiple<T, U> { }
//No error
class Node4<T> : BaseNodeMultiple<T, int> { }
//No error
class Node5<T, U> : BaseNodeMultiple<T, U> { }
//Generates an error
//class Node6<T> : BaseNodeMultiple<T, U> {}
Classes genéricas que herdam a tipos abertos construídos devem especificar restrições são um superconjunto de ou implica, as restrições no tipo de base:
class NodeItem<T> where T : System.IComparable<T>, new() { }
class SpecialNodeItem<T> : NodeItem<T> where T : System.IComparable<T>, new() { }
Tipos genéricos podem usar vários parâmetros de tipo e restrições, da seguinte forma:
class SuperKeyType<K, V, U>
where U : System.IComparable<U>
where V : new()
{ }
em aberto tipos construídos construídos e fechados podem ser usados sistema autônomo parâmetros do método:
void Swap<T>(List<T> list1, List<T> list2)
{
//code to swap items
}
void Swap(List<int> list1, List<int> list2)
{
//code to swap items
}
Se uma classe genérica implementa uma interface, todas as ocorrências dessa classe podem ser convertidas para essa interface.
Classes genéricas são invariável.Em Outros palavras, se um parâmetro de entrada especifica um List<BaseClass>, você obterá um erro em time de compilar se você tentar fornecer um List<DerivedClass>.
Consulte também
Conceitos
Referência
Generics (Guia de programação C#)