C# Academy · Lección

Restricciones where

Restrinja los parámetros de tipo

Restricciones where es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 3 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.

Por qué existen las restricciones

De forma predeterminada, un parámetro de tipo T se trata casi como object, por lo que el compilador permite muy pocas operaciones sobre él. Las restricciones, escritas con where, proporcionan más información al compilador sobre T.

Con esa información, se pueden llamar métodos, construir instancias o comparar valores de forma segura.

void Show<T>(T value) where T : IFormattable
{
    // now ToString(format, provider) is available
}

Restricciones de interfaz

Una restricción de interfaz exige que T implemente una interfaz determinada. De este modo, el cuerpo puede llamar a los miembros de esa interfaz.

En el ejemplo siguiente, where T : IComparable<T> garantiza que existe un método CompareTo.

T Max<T>(T a, T b) where T : IComparable<T>
    => a.CompareTo(b) >= 0 ? a : b;

Restricciones de clase base

Se puede exigir que T derive de una clase base específica. Así, los miembros de ese tipo base se pueden usar dentro del código genérico.

Esto es habitual en marcos de trabajo en los que todas las entidades comparten un tipo base.

class Animal { public string Name = ""; }

string NameOf<T>(T a) where T : Animal => a.Name;

La restricción class

where T : class exige que T sea un tipo por referencia. Esto permite asignar null y comprobar la igualdad de referencias.

Es habitual en repositorios, cachés y cualquier elemento que almacene referencias que puedan ser nulas.

T? FindOrNull<T>(bool found, T value) where T : class
    => found ? value : null;

La restricción struct

where T : struct exige que T sea un tipo por valor que no admita valores nulos. Esto permite tratar T como un tipo por valor y usar T? como tipo por valor anulable.

La utilizan los auxiliares que funcionan únicamente con números, enumeraciones o estructuras pequeñas.

T? AsNullable<T>(T value) where T : struct
    => value;

La restricción new()

La restricción new() exige que T tenga un constructor público sin parámetros. Entonces, el cuerpo puede escribir new T().

Las fábricas y los pools de objetos dependen de ella para crear instancias de forma genérica.

using System;

class Program
{
    static T Make<T>() where T : new() => new T();

    static void Main()
    {
        var list = Make<System.Collections.Generic.List<int>>();
        Console.WriteLine(list.Count);
    }
}

Combinar restricciones

Se pueden aplicar varias restricciones a un mismo parámetro. Las reglas de orden exigen colocar primero class o struct, después la clase base, luego las interfaces y, por último, new().

Las restricciones se enumeran después de una única cláusula where, separadas por comas.

T Build<T>() where T : class, IComparable<T>, new()
    => new T();

Varias cláusulas where

Cuando un método o una clase tiene varios parámetros de tipo, cada uno obtiene su propia cláusula where. Se escriben una después de otra.

Esto mantiene claramente separadas las restricciones de cada parámetro.

TResult Convert<TInput, TResult>(TInput x)
    where TInput : class
    where TResult : new()
    => new TResult();

Un ejemplo ejecutable de restricciones

Este programa completo usa una restricción IComparable<T> para encontrar el mayor de dos valores, tanto con enteros como con cadenas.

La restricción es lo que hace que CompareTo sea válido dentro del método.

using System;

class Program
{
    static T Max<T>(T a, T b) where T : IComparable<T>
        => a.CompareTo(b) >= 0 ? a : b;

    static void Main()
    {
        Console.WriteLine(Max(3, 9));
        Console.WriteLine(Max("apple", "pear"));
    }
}

Las restricciones notnull y unmanaged

Las versiones más recientes de C# añaden más restricciones. where T : notnull prohíbe los tipos anulables, lo que resulta útil para las claves de diccionarios. where T : unmanaged restringe T a tipos por valor blittable para código de bajo nivel.

Estas restricciones refuerzan la seguridad en escenarios especializados.

void Use<T>(T key) where T : notnull { }

unsafe void Raw<T>(T v) where T : unmanaged { }

Las restricciones habilitan capacidades, no las limitan

Aunque parecen limitaciones, las restricciones en realidad desbloquean capacidades. Sin una restricción, apenas se puede interactuar con T; con una, se obtiene acceso a sus miembros.

Elija la restricción mínima que permita funcionar al algoritmo y mantenga el parámetro de tipo lo más flexible posible.

// No constraint: only object members available
string Name<T>(T x) => x.ToString();

Comprobación rápida

Compruebe su comprensión de las restricciones where.

Resumen

La cláusula where restringe los parámetros de tipo mediante interfaces, clases base, class, struct, new(), notnull y unmanaged. Cada restricción habilita operaciones específicas sobre T.

Colóquelas en el orden correcto, use una cláusula por parámetro y elija la restricción mínima que necesite el algoritmo.

Preguntas frecuentes

¿La lección «Restricciones where» es gratis?

Sí — el texto completo de «Restricciones where» 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 «Restricciones where»?

Restrinja los parámetros de tipo 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 3 de 4.

¿Cuánto tiempo toma la lección «Restricciones where»?

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

← Volver a C# Academy