unmanaged, notnull y new() (emulación de C# 6)
C# 6 admite las restricciones class, struct y new(); emule las restricciones más recientes notnull/unmanaged mediante validaciones, el diseño de la API y convenciones.
unmanaged, notnull y new() (emulación de C# 6) es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 1 de 3. 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 3 lecciones en total.
Panorama de restricciones
Objetivo: Utilice eficazmente las restricciones genéricas de C# 6.
- class frente a struct
- new() para crear instancias sin Activator
- Emule notnull/unmanaged mediante guards y el diseño de la API
class frente a struct
class limita T a tipos de referencia; struct limita T a tipos de valor. Los usos incorrectos producen un error en tiempo de compilación.
using System;
// Works only for reference types
public static class RefBox
{
public static string Show<T>(T value) where T : class
{
return value == null ? "null ref" : "ref: " + value.ToString();
}
}
// Works only for value types
public static class ValBox
{
public static string Show<T>(T value) where T : struct
{
return "value: " + value.ToString();
}
}
public class Program
{
public static void Main(string[] args)
{
string s = "hello";
int n = 42;
Console.WriteLine(RefBox.Show<string>(s)); // OK
Console.WriteLine(ValBox.Show<int>(n)); // OK
// Console.WriteLine(RefBox.Show<int>(n)); // compile-time error (int is struct)
// Console.WriteLine(ValBox.Show<string>(s)); // compile-time error (string is class)
}
}
new() en la práctica
new() garantiza un constructor público sin parámetros, por lo que el código genérico puede llamar directamente a new T().
using System;
// Requires public parameterless ctor on T
public static class Factory
{
public static T Create<T>() where T : new()
{
return new T(); // safe in C# 6 with new()
}
}
public sealed class Sample
{
public string Name { get; set; }
public Sample() { Name = "default"; }
}
public class Program
{
public static void Main(string[] args)
{
Sample x = Factory.Create<Sample>();
Console.WriteLine("Created: " + x.Name);
}
}
Emular notnull
C# 6 no incluye notnull. Puede aproximarlo mediante where T : class y guards explícitos para null dentro de la API.
using System;
// C# 6 has no notnull constraint. Use where T : class and guard at runtime.
public static class NotNullApi
{
public static int LengthOf<T>(T x) where T : class
{
if (x == null) throw new ArgumentNullException("x");
return x.ToString().Length; // placeholder usage
}
}
public class Program
{
public static void Main(string[] args)
{
Console.WriteLine(NotNullApi.LengthOf<string>("hi")); // 2
try
{
Console.WriteLine(NotNullApi.LengthOf<string>(null)); // throws
}
catch (Exception ex)
{
Console.WriteLine("Guard fired: " + ex.GetType().Name);
}
}
}
Emular la intención de unmanaged
C# 6 no incluye unmanaged. Puede utilizar struct e interfaces (por ejemplo, IComparable) para dirigirse a tipos de valor similares a los numéricos.
using System;
// No unmanaged constraint in C# 6.
// Use struct for value types and restrict API usage (document numeric-only intent).
public static class NumericOps
{
public static T Max<T>(T a, T b) where T : struct, IComparable
{
// Works for numeric primitives because they implement IComparable
return (a.CompareTo(b) >= 0) ? a : b;
}
}
public class Program
{
public static void Main(string[] args)
{
Console.WriteLine(NumericOps.Max<int>(3, 9)); // 9
Console.WriteLine(NumericOps.Max<double>(2.5, 2)); // 2.5
}
}
Consejos prácticos
Consejos:
- Elija class/struct para restringir T desde el principio.
- Use new() si necesita crear una instancia de T.
- Emule notnull mediante guards en tiempo de ejecución.
- Emule unmanaged mediante struct y un uso documentado (a menudo, tipos primitivos numéricos).
Restricción del constructor
Repaso
Repaso: Use class/struct/new() en C# 6. Emule notnull con comprobaciones de null y la intención de unmanaged con límites de struct e interfaces.
Preguntas frecuentes
¿La lección «unmanaged, notnull y new() (emulación de C# 6)» es gratis?
Sí — el texto completo de «unmanaged, notnull y new() (emulación de C# 6)» 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 3 lecciones en total.
¿Qué aprenderé en «unmanaged, notnull y new() (emulación de C# 6)»?
C# 6 admite las restricciones class, struct y new(); emule las restricciones más recientes notnull/unmanaged mediante validaciones, el diseño de la API y convenciones. 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 1 de 3.
¿Cuánto tiempo toma la lección «unmanaged, notnull y new() (emulación de C# 6)»?
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
- unmanaged, notnull y new() (emulación de C# 6)
- Matemática genérica (visión general) y atributos genéricos (cuando corresponda)
- Utilidades genéricas reutilizables