Interfaces genéricas
Abstraiga los tipos
Interfaces genéricas es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 4 lecciones en total.
¿Qué es una interfaz genérica?
Una interfaz genérica declara parámetros de tipo entre corchetes angulares después de su nombre. Las clases que la implementan eligen los tipos concretos y el contrato de la interfaz se adapta en consecuencia.
La biblioteca .NET las usa en todas partes, por ejemplo, IEnumerable<T> e IComparable<T>.
interface IRepository<T>
{
void Add(T item);
T Get(int id);
}Implementar una interfaz genérica
Una clase puede implementar una interfaz genérica proporcionando un argumento de tipo concreto. Las firmas de los métodos utilizan entonces ese tipo real.
Esto produce un contrato seguro y reutilizable sin conversiones.
using System.Collections.Generic;
class IntStore : IRepository<int>
{
private readonly List<int> data = new();
public void Add(int item) => data.Add(item);
public int Get(int id) => data[id];
}
interface IRepository<T>
{
void Add(T item);
T Get(int id);
}Mantener la genericidad de la clase implementadora
Una clase puede implementar una interfaz genérica y seguir siendo genérica, transmitiendo su propio parámetro de tipo a la interfaz.
Esto mantiene la implementación reutilizable para cualquier tipo de elemento.
using System.Collections.Generic;
class Store<T> : IRepository<T>
{
private readonly List<T> data = new();
public void Add(T item) => data.Add(item);
public T Get(int id) => data[id];
}
interface IRepository<T> { void Add(T item); T Get(int id); }IComparable<T> en acción
IComparable<T> es una interfaz genérica integrada. Implementarla permite que el tipo defina cómo se ordenan sus instancias, lo que habilita la ordenación.
El método CompareTo devuelve un valor negativo, cero o positivo.
class Money : IComparable<Money>
{
public int Cents;
public int CompareTo(Money? other)
=> Cents.CompareTo(other?.Cents ?? 0);
}Implementar IEnumerable<T>
IEnumerable<T> es la base de LINQ y de foreach. Un tipo que la implementa se puede recorrer. A menudo, se delega en el iterador de una colección interna.
Los métodos iteradores con yield return facilitan esta tarea.
using System.Collections;
using System.Collections.Generic;
class Bag<T> : IEnumerable<T>
{
private readonly List<T> items = new();
public void Add(T x) => items.Add(x);
public IEnumerator<T> GetEnumerator() => items.GetEnumerator();
IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}Una interfaz genérica ejecutable
Este programa completo define una interfaz genérica IPrinter<T>, la implementa para cadenas y, después, la utiliza.
La interfaz garantiza un método Print independientemente del tipo concreto.
using System;
interface IPrinter<T> { void Print(T value); }
class ConsolePrinter<T> : IPrinter<T>
{
public void Print(T value) => Console.WriteLine(value);
}
class Program
{
static void Main()
{
IPrinter<string> p = new ConsolePrinter<string>();
p.Print("hello generics");
}
}Covarianza con out
Un parámetro de una interfaz genérica marcado con out es covariante: aparece únicamente en posiciones de salida. Esto permite usar IEnumerable<Cat> donde se espera IEnumerable<Animal>.
La covarianza conserva la compatibilidad de asignación a lo largo de una cadena de herencia.
interface IProducer<out T>
{
T Produce();
}Contravarianza con in
Un parámetro marcado con in es contravariante: aparece únicamente en posiciones de entrada. Esto permite usar un IComparer<Animal> donde se necesita un IComparer<Cat>.
La contravarianza invierte la dirección de la asignabilidad para los consumidores.
interface IConsumer<in T>
{
void Consume(T item);
}Múltiples parámetros de tipo
Las interfaces genéricas pueden aceptar más de un parámetro. IDictionary<TKey, TValue> es un ejemplo conocido, con tipos independientes para la clave y el valor.
Cada parámetro puede ser invariante, covariante o contravariante de forma independiente.
interface IMapper<TIn, TOut>
{
TOut Map(TIn input);
}Programar contra la interfaz
Depender de una interfaz genérica en lugar de una clase concreta hace que el código sea flexible. Puede cambiar las implementaciones sin modificar a quienes las utilizan.
Los parámetros de método escritos como IEnumerable<T> aceptan por igual listas, matrices y resultados de consultas.
using System.Collections.Generic;
using System.Linq;
int Total(IEnumerable<int> values) => values.Sum();Restricciones mediante interfaces genéricas
Las interfaces genéricas aparecen con frecuencia como restricciones. where T : IComparable<T> permite que un método ordene o compare sus entradas.
Esto combina dos características de los genéricos para crear algoritmos seguros y reutilizables.
T Min<T>(T a, T b) where T : IComparable<T>
=> a.CompareTo(b) <= 0 ? a : b;Comprobación rápida
Compruebe cuánto entiende las interfaces genéricas.
Repaso
Las interfaces genéricas declaran parámetros de tipo y permiten que quienes las implementan los fijen o los propaguen. Algunos ejemplos integrados son IEnumerable<T>, IComparable<T> y IDictionary<TKey, TValue>.
Las anotaciones de varianza out e in habilitan la covarianza y la contravarianza, y las interfaces genéricas se combinan naturalmente con las restricciones where.
Aprende C# con un tutor de IA — gratis
Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.
- Cursos
- 93
- Lecciones
- 346
Preguntas frecuentes
¿La lección «Interfaces genéricas» es gratis?
Sí — el texto completo de «Interfaces genéricas» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Interfaces genéricas»?
Abstraiga los tipos Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar C# Academy?
No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.
¿Cuánto tiempo toma la lección «Interfaces genéricas»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de C# Academy?
Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Métodos genéricos
- Clases genéricas
- Restricciones where
- Interfaces genéricas