C# distingue entre tipos que pueden ser de los que no pueden. Los () permiten que los tipos de valor contengan null, los (una característica del compilador) ayudan a detectar errores relacionados con null, y los (, , ) hacen que trabajar con valores posiblemente nulos sea limpio y seguro — abordando el problema ubicuo de referencia nula.
nullint??.??!int x = 5; // a value type — CANNOT be null
int? y = null; // int? = Nullable<int> — CAN be null
if (y.HasValue) { int val = y.Value; } // check + access
int z = y ?? 0; // default if null
Los tipos de valor normalmente no pueden ser null, pero int? (Nullable<int>) lo permite — común para datos opcionales/faltantes (por ejemplo, una columna de base de datos anulable).
#nullable enable // (on by default in modern projects)
string name = null; // ⚠️ warning — string is non-nullable by default now
string? maybe = null; // ✅ string? explicitly allows null
void Use(string? s) {
Console.WriteLine(s.Length); // ⚠️ warning — s might be null (must check first)
}
Con tipos de referencia anulábles habilitados, el compilador rastrea qué referencias pueden ser null (string?) frente a las que no (string) y advierte cuando podrías desreferenciar null — detectando errores de NullReferenceException en tiempo de compilación. Esta es una característica de seguridad de C# moderno importante.
// ?. null-conditional — short-circuits to null instead of throwing
int? len = user?.Name?.Length; // null if user or Name is null (no exception)
user?.DoSomething(); // only calls if user isn't null
// ?? null-coalescing — provide a default
string name = input ?? "Anonymous";
name ??= "fallback"; // assign if currently null
// ! null-forgiving — assert non-null (suppress the warning; use carefully)
string definitelyNotNull = maybe!; // "I know it's not null" — no runtime check
El operador null-condicional (?.) accede de forma segura a miembros de valores posiblemente nulos (devolviendo null en lugar de lanzar una excepción), y ?? proporciona valores por defecto — juntos hacen que el manejo de nulos sea limpio y seguro.
El manejo de nulos es uno de los aspectos más importantes para escribir C# robusto, ya que NullReferenceException ("el error de mil millones de dólares") es uno de los errores de tiempo de ejecución más comunes — y los tipos anulábles y operadores de C# los abordan directamente, haciéndolos conocimiento esencial. Los tipos de valor anulábles (int?) son prácticamente necesarios para representar datos opcionales/faltantes (campos de base de datos anulábles, valores opcionales).
La característica tipos de referencia anulábles (ahora activada por defecto en proyectos modernos de .NET) es una mejora importante de seguridad: al hacer que el compilador rastree y advierta sobre posibles desreferencias nulas, detecta toda una clase de errores relacionados con null en tiempo de compilación en lugar de como bloqueos en tiempo de ejecución — un beneficio de confiabilidad significativo que debes entender y seguir.
Los operadores de manejo de nulos son herramientas cotidianas que hacen que trabajar con valores posiblemente nulos sea limpio y seguro: el operador null-condicional (?.) navega de forma segura cadenas posiblemente nulas (devolviendo null en lugar de lanzar), ??/??= proporcionan valores por defecto de forma concisa, y ! afirma que no es null (se debe usar con cuidado).
Entender los tipos de valor anulábles, la característica de seguridad de tipos de referencia anulábles, y los operadores de manejo de nulos (?., ??, !) es importante para escribir C# seguro en relación a nulos y robusto que evite la NullReferenceException ubicua — una preocupación frecuente y prácticamente crítica.
Ya que los errores relacionados con null son tan comunes y C# proporciona herramientas sólidas (especialmente verificación de null en tiempo de compilación) para prevenirlos, dominar los tipos anulábles y operadores de null es conocimiento fundamental e imprescindible para escribir C# moderno confiable.
Una biblioteca de preguntas de entrevista de IT con respuestas detalladas — de Junior a Senior.
Donar