Genéricos en .NET Framework

Los genéricos le permiten personalizar un método, clase, estructura o interfaz para el tipo de datos preciso sobre el que actúa. Por ejemplo, en lugar de utilizar la clase Hashtable, que permite que las claves y valores sean de cualquier tipo, puede usar la clase genérica Dictionary<TKey, TValue> y especificar el tipo permitido para la clave y el tipo permitido para el valor. Entre los beneficios de los genéricos se encuentran una mayor posibilidad de reutilización del código y la seguridad de tipos.

En este tema se proporciona información general sobre los genéricos en .NET Framework y un resumen de los métodos o los tipos genéricos. Contiene las siguientes secciones:

• Definir y utilizar genéricos

• Terminología de los genéricos

• Compatibilidad con bibliotecas de clases y con lenguajes

• Tipos anidados y genéricos

• Temas relacionados

• Referencia

Definir y utilizar genéricos

Los genéricos son clases, estructuras, interfaces y métodos que tienen marcadores de posición (parámetros de tipo) para uno o varios de los tipos que almacenan o utilizan. Una clase de una colección genérica podría usar un parámetro de tipo como marcador de posición para el tipo de objetos que almacena; los parámetros de tipo aparecen como los tipos de sus campos y los tipos de parámetros de sus métodos. Un método genérico podría usar su parámetro de tipo como el tipo de su valor devuelto o como el tipo de uno de sus parámetros formales. El código siguiente muestra una definición de clase genérica simple.

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

Cuando crea una instancia de una clase genérica, especifica los tipos reales que sustituir para los parámetros de tipo. Así se establece una nueva clase genérica, llamada clase genérica construida, con sus tipos elegidos sustituidos en todas las apariciones de los parámetros de tipo. El resultado es una clase con seguridad de tipos que se adapta a su elección de tipos, como se ilustra en el código siguiente.

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

Volver al principio

Terminología de los genéricos

Los términos que se incluyen a continuación se utilizan para explicar los genéricos en .NET Framework:

• Una definición de tipo genérico es una declaración de interfaz, clase o estructura que funciona como una plantilla, con marcadores de posición para los tipos que puede contener o utilizar. Por ejemplo, la clase System.Collections.Generic.Dictionary<TKey, TValue> puede contener dos tipos: claves y valores. Puesto que una definición de tipo genérico es solo una plantilla, no puede crear instancias de una clase, estructura o interfaz que sea una definición de tipo genérico.

• Los parámetros de tipo genéricos, o parámetros de tipo, son los marcadores de posición de un tipo genérico o definición de método. El tipo genérico System.Collections.Generic.Dictionary<TKey, TValue> tiene dos parámetros de tipo, TKey y TValue, que representan los tipos de sus claves y valores.

• Un tipo genérico construido, o tipo construido, es el resultado de especificar los tipos para los parámetros de tipo genérico de una definición de tipo genérico.

• Un argumento de tipo genérico es cualquier tipo que se sustituye para un parámetro de tipo genérico.

• El término general tipo genérico incluye tanto los tipos construidos como las definiciones de tipos genéricos.

• La covarianza y contravarianza de parámetros de tipo genérico le permiten usar tipos genéricos construidos cuyos argumentos de tipo más derivado (covarianza) o menos derivado (contravarianza) que un tipo construido de destino. La covarianza y la contravarianza se denominan colectivamente varianza. Para obtener más información, vea Covarianza y contravarianza en genéricos.

• Las restricciones son límites colocados en parámetros de tipo genérico. Por ejemplo, podría limitar un parámetro de tipo a los tipos que implementa la interfaz genérica System.Collections.Generic.IComparer<T> para garantizar que se pueden ordenar esas instancias del tipo. También puede restringir los parámetros de tipo a los tipos que tienen una clase base concreta, que tienen un constructor predeterminado o que son tipos de referencia o tipos de valor. Los usuarios del tipo genérico no pueden sustituir los argumentos de tipo que no cumplen las restricciones.

• Una definición de método genérico es un método con dos listas de parámetros: una lista de parámetros de tipo genérico y una lista de parámetros formales. Los parámetros de tipo pueden aparecer como el tipo de valor devuelto o como los tipos de los parámetros formales, tal y como se muestra en el código siguiente.

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

Los métodos genéricos pueden aparecer en tipos genéricos o no genéricos. Es importante señalar que un método no es genérico sólo porque pertenezca a un tipo genérico, o incluso porque tenga parámetros formales cuyos tipos son los parámetros genéricos del tipo que los envuelve. Un método sólo es genérico si tiene su propia lista de parámetros de tipo. En el código siguiente, sólo el método G es 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;
    }
};

Volver al principio

Compatibilidad con bibliotecas de clases y con lenguajes

.NET Framework proporciona varias clases de colección genéricas en los espacios de nombres siguientes:

• El espacio de nombres System.Collections.Generic cataloga la mayoría de los tipos de colección genéricos proporcionados por .NET Framework, como las clases genéricas List<T> y Dictionary<TKey, TValue>.

• El espacio de nombres System.Collections.ObjectModel cataloga tipos de colección genéricos adicionales, como la clase genérica ReadOnlyCollection<T>, que son útiles para exponer modelos de objetos a los usuarios de sus clases.

Las interfaces genéricas para implementar comparaciones de orden e igualdad se proporcionan en el espacio de nombres System, junto con los tipos de delegado genéricos para los controladores de eventos, conversiones y predicados de búsqueda.

Se ha agregado compatibilidad con genéricos al espacio de nombres System.Reflection para examinar tipos y métodos genéricos, a System.Reflection.Emit para emitir ensamblados dinámicos que contienen tipos y métodos genéricos, y a System.CodeDom para generar gráficos de origen que incluyen genéricos.

Common Language Runtime proporciona nuevos códigos de operación y prefijos para admitir tipos genéricos en el lenguaje intermedio de Microsoft (MSIL), incluyendo Stelem, Ldelem, Unbox_Any, Constrained y Readonly.

Visual C++, C# y Visual Basic proporcionan compatibilidad completa para definir y usar genéricos. Para obtener más información sobre la compatibilidad con lenguajes, vea Tipos genéricos en Visual Basic (Visual Basic), Introducción a los genéricos (Guía de programación de C#) y Overview of Generics in Visual C++.

Volver al principio

Tipos anidados y genéricos

Un tipo que está anidado en un tipo genérico puede depender de los parámetros de tipo del tipo genérico envolvente. Common Language Runtime considera que los tipos anidados son genéricos, aunque no tengan parámetros de tipo genérico propios. Cuando se crea una instancia de un tipo anidado, es necesario especificar los argumentos de tipo de todos los tipos genéricos envolventes.

Volver al principio

Temas relacionados

Volver al principio

Referencia

System.Collections.Generic

System.Collections.ObjectModel

System.Reflection.Emit.OpCodes

Volver al principio