Tipos de referencia anulables (nociones) y anotaciones (patrones de C# 6)
C# 6 no tiene tipos de referencia anulables (string?). Aprenda a gestionar null de forma segura: validaciones de entrada, documentación clara, el helper Require.NotNull y la comparación con Nullable para tipos de valor.
Tipos de referencia anulables (nociones) y anotaciones (patrones de C# 6) es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 3 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.
Consideraciones sobre NRT y alternativa
Idea: Los tipos de referencia que admiten valores NULL (por ejemplo, string?) añaden comprobaciones del compilador en las versiones más recientes de C#.
- C# 6 no admite string?
- Use validaciones, documentación clara y sencillos métodos auxiliares
- Devuelva valores no nulos de forma predeterminada
Protección frente a valores NULL
Añada comprobaciones con ArgumentNullException para los parámetros de tipo de referencia; después, trate los valores como no nulos.
using System;
public static class Greeter
{
// Contract: name must not be null (C# 6 has no string? to enforce)
public static string Hello(string name)
{
if (name == null) throw new ArgumentNullException("name"); // guard
return "Hello " + name.ToUpper(); // safe after guard
}
}
public class Program
{
public static void Main(string[] args)
{
Console.WriteLine(Greeter.Hello("Ada"));
try
{
Console.WriteLine(Greeter.Hello(null)); // will throw (by design)
}
catch (Exception ex)
{
Console.WriteLine("Caught: " + ex.GetType().Name);
}
}
}
Método auxiliar Require.NotNull
Cree un pequeño método auxiliar Require.NotNull para reducir el código repetitivo y dejar clara la intención.
using System;
public static class Require
{
// Works for reference types; returns the validated value
public static T NotNull<T>(T value, string name) where T : class
{
if (value == null) throw new ArgumentNullException(name);
return value;
}
}
public sealed class Email
{
public string Address { get; private set; }
public Email(string address)
{
Address = Require.NotNull(address, "address").Trim();
}
}
public class Program
{
public static void Main(string[] args)
{
Email e = new Email("user@mail.com");
Console.WriteLine(e.Address);
}
}
Nullable<T> frente a referencias
Nullable<T> (por ejemplo, int?) se usa para tipos de valor. Los tipos de referencia ya pueden ser null; en C# 6 usamos comprobaciones.
using System;
public class Program
{
public static void Main(string[] args)
{
int x = 5; // value type (non-nullable)
int? maybe = null; // Nullable<T> works for value types
Console.WriteLine("x=" + x);
Console.WriteLine("maybe has value? " + maybe.HasValue);
Console.WriteLine("maybe or default: " + (maybe ?? -1));
}
}
Documentación de los contratos de nulabilidad
Indique la nulabilidad en la documentación XML y sea coherente: devuelva siempre valores no nulos o documente claramente cuándo es posible devolver null.
using System;
/// <summary>
/// Parses "key=value" and returns the value part.
/// Returns null if the format is invalid.
/// </summary>
public static class Parser
{
// Explicitly document when null can be returned.
public static string TryGetValue(string line)
{
if (line == null) throw new ArgumentNullException("line");
int idx = line.IndexOf("=");
if (idx < 0 || idx == line.Length - 1) return null; // documented nullable return
return line.Substring(idx + 1);
}
}
public class Program
{
public static void Main(string[] args)
{
Console.WriteLine(Parser.TryGetValue("a=1"));
Console.WriteLine(Parser.TryGetValue("oops")); // prints nothing (null)
}
}
Lista de comprobación de seguridad frente a NULL (C# 6)
Lista de comprobación:
- Valide las entradas con ArgumentNullException.
- Devuelva valores no nulos de forma predeterminada y documente cualquier retorno que pueda ser null.
- Use métodos auxiliares pequeños (Require.NotNull) para mantener el código ordenado.
- Cuando sea razonable, prefiera sobrecargas que eviten los valores null (por ejemplo, una cadena vacía en lugar de null).
Seguridad frente a NULL en C# 6
Repaso
Repaso: Los NRT son una característica más reciente. En C# 6, manténgase seguro mediante comprobaciones, documentación clara, métodos auxiliares y contratos de retorno predecibles que no devuelvan null.
Preguntas frecuentes
¿La lección «Tipos de referencia anulables (nociones) y anotaciones (patrones de C# 6)» es gratis?
Sí — el texto completo de «Tipos de referencia anulables (nociones) y anotaciones (patrones 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 «Tipos de referencia anulables (nociones) y anotaciones (patrones de C# 6)»?
C# 6 no tiene tipos de referencia anulables (string?). Aprenda a gestionar null de forma segura: validaciones de entrada, documentación clara, el helper Require.NotNull y la comparación con Nullable… 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 3.
¿Cuánto tiempo toma la lección «Tipos de referencia anulables (nociones) y anotaciones (patrones 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
- Métodos/tipos genéricos y restricciones
- Varianza (in/out) con interfaces y delegados
- Tipos de referencia anulables (nociones) y anotaciones (patrones de C# 6)