Genéricos (Guía de programación de C#)Generics (C# Programming Guide)

Los genéricos se han agregado a la versión 2.0 del lenguaje C# y Common Language Runtime (CLR).Generics were added to version 2.0 of the C# language and the common language runtime (CLR). Los genéricos introducen en .NET Framework el concepto de parámetros de tipo, lo que le permite diseñar clases y métodos que aplazan la especificación de uno o varios tipos hasta que el código de cliente declare y cree una instancia de la clase o el método.Generics introduce to the .NET Framework the concept of type parameters, which make it possible to design classes and methods that defer the specification of one or more types until the class or method is declared and instantiated by client code. Por ejemplo, al usar un parámetro de tipo genérico T puede escribir una clase única que otro código de cliente puede usar sin incurrir en el costo o riesgo de conversiones en tiempo de ejecución u operaciones de conversión boxing, como se muestra aquí:For example, by using a generic type parameter T you can write a single class that other client code can use without incurring the cost or risk of runtime casts or boxing operations, as shown here:

// Declare the generic class.
public class GenericList<T>
{
    public void Add(T input) { }
}
class TestGenericList
{
    private class ExampleClass { }
    static void Main()
    {
        // Declare a list of type int.
        GenericList<int> list1 = new GenericList<int>();
        list1.Add(1);

        // Declare a list of type string.
        GenericList<string> list2 = new GenericList<string>();
        list2.Add("");

        // Declare a list of type ExampleClass.
        GenericList<ExampleClass> list3 = new GenericList<ExampleClass>();
        list3.Add(new ExampleClass());
    }
}

Las clases y métodos genéricos combinan reusabilidad, seguridad de tipos y eficacia de una manera en que sus homólogos no genéricos no pueden.Generic classes and methods combine reusability, type safety and efficiency in a way that their non-generic counterparts cannot. Los genéricos se usan frecuentemente con colecciones y los métodos que funcionan en ellas.Generics are most frequently used with collections and the methods that operate on them. La versión 2.0 de la biblioteca de clases .NET Framework proporciona un nuevo espacio de nombres, System.Collections.Generic, que contiene varias clases de colección nuevas basadas en 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. Se recomienda que todas las aplicaciones destinadas a .NET Framework 2.0 y versiones posteriores usen las nuevas clases de colección genéricas en lugar de sus homólogas no genéricas anteriores como 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 más información, vea Elementos genéricos en .NET.For more information, see Generics in .NET.

Por supuesto, también se pueden crear tipos y métodos genéricos personalizados para proporcionar soluciones y patrones de diseño generalizados propios con seguridad de tipos y eficaces.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. En el ejemplo de código siguiente se muestra una clase genérica simple de lista vinculada para fines de demostración.The following code example shows a simple generic linked-list class for demonstration purposes. (En la mayoría de los casos, se debe usar la clase List<T> proporcionada por la biblioteca de clases .NET Framework en lugar de crear una propia). El parámetro de tipo T se usa en diversas ubicaciones donde normalmente se usaría un tipo concreto para indicar el tipo del elemento almacenado en la 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. Se usa de estas formas:It is used in the following ways:

  • Como el tipo de un parámetro de método en el método AddHead.As the type of a method parameter in the AddHead method.

  • Como el tipo de valor devuelto de la propiedad Data en la clase anidada Node.As the return type of the Data property in the nested Node class.

  • Como el tipo de miembro privado data de la clase anidada.As the type of the private member data in the nested class.

Tenga en cuenta que T está disponible para la clase anidada Node.Note that T is available to the nested Node class. Cuando se crea una instancia de GenericList<T> con un tipo concreto, por ejemplo como un GenericList<int>, cada repetición de T se sustituye 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;
        }
    }
}

En el ejemplo de código siguiente se muestra cómo el código de cliente usa la clase genérica GenericList<T> para crear una lista de enteros.The following code example shows how client code uses the generic GenericList<T> class to create a list of integers. Simplemente cambiando el argumento de tipo, el código siguiente puede modificarse fácilmente para crear listas de cadenas o cualquier otro 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");
    }
}

Información general sobre los genéricosGenerics Overview

  • Use tipos genéricos para maximizar la reutilización del código, la seguridad de tipos y el rendimiento.Use generic types to maximize code reuse, type safety, and performance.

  • El uso más común de los genéricos es crear clases de colección.The most common use of generics is to create collection classes.

  • La biblioteca de clases .NET Framework contiene varias clases de colección genéricas nuevas en el espacio de nombres System.Collections.Generic.The .NET Framework class library contains several new generic collection classes in the System.Collections.Generic namespace. Estas se deberían usar siempre que sea posible en lugar de clases como ArrayList en el espacio de nombres System.Collections.These should be used whenever possible instead of classes such as ArrayList in the System.Collections namespace.

  • Puede crear sus propias interfaces, clases, métodos, eventos y delegados genéricos.You can create your own generic interfaces, classes, methods, events and delegates.

  • Puede limitar las clases genéricas para habilitar el acceso a métodos en tipos de datos determinados.Generic classes may be constrained to enable access to methods on particular data types.

  • Puede obtener información sobre los tipos que se usan en un tipo de datos genérico en tiempo de ejecución mediante la reflexión.Information on the types that are used in a generic data type may be obtained at run-time by using reflection.

Para obtener más información:For more information:

Especificación del lenguaje C#C# Language Specification

Para obtener más información, consulte la Especificación del lenguaje C#.For more information, see the C# Language Specification.

Vea tambiénSee also