Classes genéricas no .NET Framework
Os Genéricos permitem que você ajuste um método, classe, estrutura ou interface para o tipo de dados sobre os quais eles podem agir. Por exemplo, em vez de usar a classe Hashtable, que permite que as chaves e valores sejam de qualquer tipo, você pode usar a classe genérica Dictionary<TKey, TValue> e especificar o tipo permitido para a chave e o tipo permitido para o valor. Entre os benefícios de genéricos estão superior reutilização de código e segurança de tipos.
Este tópico fornece uma visão geral das classes genéricas no .NET Framework e um resumo dos tipos ou métodos genéricos. Ele contém as seguintes seções:
Definindo e usando classes genéricas
Terminologia das Classes Genéricas
Biblioteca de classe e o suporte ao idioma
Tipos aninhados e classes genéricas
Tópicos relacionados
Referência
Definindo e usando classes genéricas
As classes, estruturas, interfaces e os métodos genéricos possuem espaços reservados (parâmetros de tipo) para um ou mais dos tipos que eles armazenam ou usam. Uma classe de coleção genérica pode usar um parâmetro de tipo como um espaço reservado para o tipo de objetos que ela armazena; os parâmetros de tipo aparecem como os tipos de seus campos e os tipos de parâmetro de seus métodos. Um método genérico pode usar seu parâmetro de tipo como o tipo de seu valor de retorno ou como o tipo de um dos seus parâmetros formais. O código a seguir ilustra uma definição de classe genérica simples.
Public Class Generic(Of T)
Public Field As T
End Class
public class Generic<T>
{
public T Field;
}
generic<typename T>
public ref class Generics
{
public:
T Field;
};
Quando você cria uma instância de uma classe genérica, você especifica os tipos reais para substituir os parâmetros de tipo. Isso estabelece uma nova classe genérica, conhecida como uma classe genérica construída, com seus tipos escolhidos substituídos em todos os lugares em que aparecem os parâmetros de tipo. O resultado é uma classe de tipos seguros que seja adequada para sua escolha de tipos, como mostra o código a seguir.
Public Shared Sub Main()
Dim g As New Generic(Of String)
g.Field = "A string"
'...
Console.WriteLine("Generic.Field = ""{0}""", g.Field)
Console.WriteLine("Generic.Field.GetType() = {0}", g.Field.GetType().FullName)
End Sub
public static void Main()
{
Generic<string> g = new Generic<string>();
g.Field = "A string";
//...
Console.WriteLine("Generic.Field = \"{0}\"", g.Field);
Console.WriteLine("Generic.Field.GetType() = {0}", g.Field.GetType().FullName);
}
static void Main()
{
Generics<String^>^ g = gcnew Generics<String^>();
g->Field = "A string";
//...
Console::WriteLine("Generics.Field = \"{0}\"", g->Field);
Console::WriteLine("Generics.Field.GetType() = {0}", g->Field->GetType()->FullName);
}
Voltar ao topo
Terminologia das Classes Genéricas
Os seguintes termos são usados para discutir as classes e métodos genéricos no .NET Framework:
Uma definição de tipo genérico é uma classe, estrutura ou declaração de interface que funciona como um modelo com espaços reservados para os tipos que ele pode conter ou usar. Por exemplo, o System.Collections.Generic.Dictionary<TKey, TValue> classe pode conter dois tipos: chaves e valores. Como uma definição de tipo genérico é apenas um modelo, é possível criar instâncias de uma classe, estrutura ou interface é uma definição de tipo genérico.
Parâmetros de tipo genérico ,ou parâmetros de tipo , são os espaços reservados na definição de um tipo ou método genérico. O tipo genérico System.Collections.Generic.Dictionary<TKey, TValue> possui dois parâmetro de tipos, TKey e TValue,que representam os tipos de suas chaves e valores.
Um tipo genérico construído , ou tipo construído , é o resultado da especificação de tipos para os parâmetros de tipo genéricos de uma definição de tipo genérico.
Um argumento de tipo genérico é qualquer tipo que seja substituído por um parâmetro de tipo genérico.
O termo geral tipo genérico inclui tipos construídos e definições de tipo genérico.
Covariância e /contravariância de tipo genérico parâmetros permitem que você use construídos tipos genéricos, cujos argumentos de tipo são mais derivado (covariância) ou menos/derivada (contravariância) de um destino construído tipo. Covariância e/contravariância são coletivamente chamados de variação. Para obter mais informações, consulte Covariância e/contravariância no genéricos.
Restrições de limites que são colocadas nos parâmetros de tipo genérico. Por exemplo, você pode limitar um parâmetro de tipo para tipos que implementem a interface genérica System.Collections.Generic.IComparer<T> , para garantir que instâncias do tipo possam ser classificadas. Você também pode restringir parâmetros de tipo para tipos que têm uma determinada classe base, que têm um construtor padrão, ou que são tipos de referência ou tipos de valor. Os usuários do tipo genérico não podem substituir argumentos de tipo que não satisfaçam as restrições.
A a definição de método genérico é um método com duas listas de parâmetro: uma lista de parâmetros de tipo genérico e uma lista de parâmetros formais. Parâmetros de tipo podem aparecer como o tipo de retorno ou como os tipos dos parâmetros formais, como mostra de código a seguir.
Function Generic(Of T)(ByVal arg As T) As T
Dim temp As T = arg
'...
Return temp
End Function
T Generic<T>(T arg)
{
T temp = arg;
//...
return temp;
}
generic<typename T>
T Generic(T arg)
{
T temp = arg;
//...
return temp;
}
Métodos genéricos podem aparecer em tipos genéricos ou não genéricos. É importante observar que um método é genérico não apenas porque ele pertence a um tipo genérico, ou até mesmo porque tem parâmetros formais cujos tipos são os parâmetros genéricos do tipo delimitador. Um método é genérico somente se ele tiver sua própria lista de parâmetros de tipo. No código a seguir, somente o método G é genérico.
Class A
Function G(Of T)(ByVal arg As T) As T
Dim temp As T = arg
'...
Return temp
End Function
End Class
Class Generic(Of T)
Function M(ByVal arg As T) As T
Dim temp As T = arg
'...
Return temp
End Function
End Class
class A
{
T G<T>(T arg)
{
T temp = arg;
//...
return temp;
}
}
class Generic<T>
{
T M(T arg)
{
T temp = arg;
//...
return temp;
}
}
ref class A
{
generic<typename T>
T G(T arg)
{
T temp = arg;
//...
return temp;
}
};
generic<typename T>
ref class Generic
{
T M(T arg)
{
T temp = arg;
//...
return temp;
}
};
Voltar ao topo
Biblioteca de classe e o suporte ao idioma
A.NET Framework fornece várias classes de coleção genérica nos namespaces seguintes:
O System.Collections.Generic namespace cataloga a maioria dos tipos de coleção genérica fornecidas pelo.NET Framework, como o List<T> e Dictionary<TKey, TValue> classes genéricas.
O System.Collections.ObjectModel namespace cataloga tipos adicionais de coleção genérica, como o ReadOnlyCollection<T> classe genérica, que são úteis para expor os modelos de objeto para usuários de classes.
Interfaces genéricas para a implementação de comparações de classificação e de igualdade são fornecidas no namespace System, juntamente com tipos representantes genéricos para manipuladores de eventos, conversões e predicados de busca.
Foi adicionado suporte para genéricos para o System.Reflection o namespace para examinar tipos genéricos e métodos genéricos, para System.Reflection.Emit para emitir os assemblies dinâmicos que contêm tipos genéricos e métodos e System.CodeDom para gerar gráficos de origem, que incluem os genéricos.
O common language runtime fornece novas opcodes e prefixos para oferecer suporte a tipos genéricos no Microsoft intermediate language (MSIL), incluindo Stelem, Ldelem, Unbox_Any, Constrained, e Readonly.
Visual C++, C# e Visual Basic todos oferecem suporte completo para a definição e uso de genéricos. Para obter mais informações sobre o suporte de idioma, consulte Tipos genéricos no Visual Basic (Visual Basic), Introdução ao Generics (guia de programação C#), e Overview of Generics in Visual C++.
Voltar ao topo
Tipos aninhados e classes genéricas
Um tipo que está aninhado em um tipo genérico pode depender dos parâmetros de tipo do tipo genérico delimitador. O Common Language Runtime considera tipos aninhados como genéricos, mesmo se eles ainda não tiverem parâmetros de tipo genéricos próprios. Quando você cria uma instância de um tipo aninhado, você deve especificar argumentos de tipo para todos os delimitadores de tipo genéricos.
Voltar ao topo
Tópicos relacionados
Título |
Descrição |
|---|---|
Descreve as classes de coleção genérica e outros tipos de genéricos na.NET Framework. |
|
Representantes Genéricos para Manipulação de Matrizes e Listas |
Descreve representantes genéricos para conversões, predicados de pesquisa e ações a serem tomadas nos elementos de uma matriz ou coleção. |
Descreve interfaces genéricas que fornecem a funcionalidades comuns entre famílias de tipos genéricos. |
|
Descreve a covariância e/contravariância nos parâmetros de tipo genérico. |
|
Resume as vantagens e restrições do uso de Genéricos. |
|
Fornece informações de resumo sobre as características e os cenários de uso dos tipos na coleção do.NET Framework, incluindo tipos genéricos. |
|
Descreve regras gerais para determinar quando usar tipos de coleção genérica. |
|
Explica como gerar conjuntos dinâmicos que incluem tipos e métodos genéricos. |
|
Descreve o recurso Genéricos para usuários de Visual Basic, incluindo tópicos instruções para uso e definição de tipos genéricos. |
|
Fornece uma visão geral da definição e uso de tipos genéricos para usuários C#. |
|
Descreve o recurso Genéricos para usuários C++, incluindo as diferenças entre genéricos e modelos. |
Voltar ao topo
Referência
System.Collections.ObjectModel
System.Reflection.Emit.OpCodes
Voltar ao topo