Tipos Nullables en C#

Los tipos nullables en C# son una extensión de los tipos de valor que permite que puedan contener el valor null (además de sus valores normales). Esto es útil en escenarios donde un valor puede ser opcional o no siempre está disponible.

En C#, el valor null se utiliza para representar una ausencia de valor. Sin embargo, los tipos de valor (como int, double, bool) no pueden ser null por defecto, siempre tienen un valor predeterminado.

Para abordar esta limitación, introduce los tipos nullables, que permiten que los tipos de valor puedan tener el valor null.

Declaración y uso de tipos nullables

Para declarar un tipo nullable, se usa el operador ? después del tipo de valor. Por ejemplo, int? es un tipo nullable que puede contener un entero o null.

La sintaxis para declarar un tipo nullable es simple. Por ejemplo,

int? edad = null;
double? salario = 4500.50;
bool? esActivo = null;

Aquí, numero es una variable que puede contener un entero o el valor null.

Tipos Nullables y la Estructura Nullable

Bajo el capó, la sintaxis anterior utiliza la estructura genérica Nullable<T>. Por ejemplo:

Nullable<int> miNumero = null;

Ambas formas (Nullable<T> y T?) son equivalentes, pero el uso del operador ? es más común y más sencillo de leer.

Comprobación de nulidad

Para verificar si un tipo nullable tiene un valor o es nulo, puedes usar las propiedades HasValue y Value. La propiedad HasValue indica si el tipo nullable contiene un valor:

if (edad.HasValue)
{
    Console.WriteLine($"La edad es {edad.Value}");
}
else
{
    Console.WriteLine("La edad no está asignada.");
}

Asignación de valor predeterminado

El operador de coalescencia nula ?? proporciona una forma compacta de manejar los valores nullables, permitiendo definir un valor predeterminado en caso de que el nullable sea null.

int? numero = null;
int resultado = numero ?? 5;

Console.WriteLine(resultado); // Imprime 5

Conversión entre tipos nullables y tipos no nullables

Si necesitas convertir un tipo nullable a un tipo no nullable, puedes usar la propiedad Value:

int edadNoNullable = edad.Value; // Asegúrate de que edad no es null antes de acceder a Value.

Tipos nullables y operaciones

Cuando se trabaja con tipos nullables, es importante entender cómo se comportan en las operaciones aritméticas y lógicas.

Operaciones aritméticas

Las operaciones aritméticas con tipos nullables siguen reglas específicas: si cualquiera de los operandos es null, el resultado también es null.

int? a = 10;
int? b = null;
int? suma = a + b;

Console.WriteLine(suma.HasValue ? suma.Value.ToString() : "null"); // Imprime null

Comparaciones

Las comparaciones con tipos nullables son posibles, pero el resultado puede ser null si alguno de los operandos es null.

int? x = 10;
int? y = null;

bool? esMayor = x > y;

Console.WriteLine(esMayor.HasValue ? esMayor.Value.ToString() : "null"); // Imprime null

Mejoras en C# 8.0 y versiones posteriores

A partir de C# 8.0, se introdujo la capacidad de distinguir entre tipos nullables y tipos no nullables en el sistema de tipos del lenguaje.

Esto significa que puedes marcar un tipo como “nullable” y el compilador te advertirá si intentas asignar un valor nulo a un tipo que no debería aceptar nulos.

#nullable enable

public class Persona
{
    public string Nombre { get; set; }    // No puede ser nulo
    public string? Apellido { get; set; } // Puede ser nulo
}