0Pricing
C# Academy · Lección

Operadores null-conditional y null-coalescing

Combine ?., ?[], ?? y ??= para escribir código conciso y seguro frente a null sin comprobaciones de nulidad extensas.

Operadores null-conditional y null-coalescing 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.

Patrones de código seguro frente a null

C# proporciona tres operadores específicos para gestionar valores null de forma concisa: el operador condicional de null (?., ?[]), el operador de coalescencia de null (??) y el operador de asignación con coalescencia de null (??=). En conjunto, eliminan la mayor parte del código repetitivo de las comprobaciones de null.

Operador condicional de null: ?.

?. realiza un cortocircuito y devuelve null si el lado izquierdo es null en lugar de producir una NullReferenceException. El tipo del resultado pasa a ser anulable.

User? user = GetUser(id);

// Without ?.:
string? name = null;
if (user != null) name = user.Name;

// With ?.:
string? name2 = user?.Name;

// Chained:
string? city = user?.Address?.City;

// Method call:
string? upper = user?.Name?.ToUpper();

Operador condicional de null con indexador: ?[]

?[] es el operador de índice condicional de null. Permite acceder de forma segura a elementos de matrices o colecciones cuando la propia colección podría ser null.

List<string>? tags = product?.Tags;

// Safe index access
string? firstTag = tags?[0];

// Null-conditional LINQ
int? count = tags?.Count;
bool? hasItems = tags?.Any();

// With methods:
string? joined = tags?.FirstOrDefault()?.ToUpper();

Operador de coalescencia de null: ??

?? devuelve el operando izquierdo si no es null; de lo contrario, devuelve el operando derecho, es decir, el valor alternativo. Es el reemplazo conciso de x != null ? x : fallback.

string? name = GetName();

// Without ??:
string display = name != null ? name : "Anonymous";

// With ??:
string display2 = name ?? "Anonymous";

// Chaining ?? for multiple fallbacks:
string result = primary ?? secondary ?? tertiary ?? "Default";

// Combining with ?.
string city = user?.Address?.City ?? "Unknown City";

Asignación con fusión de null: ??=

??= asigna el valor de la derecha a la variable únicamente si actualmente es null. Es ideal para los patrones de inicialización diferida.

// Lazy initialization
private List<string>? _cache;

public List<string> GetCache()
{
    _cache ??= new List<string>(); // only assigns if null
    return _cache;
}

// Equivalent to:
// if (_cache is null) _cache = new List<string>();

// In-place:
string? name = null;
name ??= "Default";
Console.WriteLine(name); // "Default"

Uso de ?. con eventos

El operador condicional de null es la forma estándar y segura para subprocesos de invocar eventos: evita la condición de carrera que se produce al comprobar null e invocar el evento por separado.

public event EventHandler<DataEventArgs>? DataReceived;

// Thread-safe event invocation:
DataReceived?.Invoke(this, new DataEventArgs(data));

// This is equivalent to:
var handler = DataReceived;
if (handler != null) handler(this, new DataEventArgs(data));
// (local copy avoids race condition between check and invoke)

Ejemplos de encadenamiento complejo

Combinar operadores permite recorrer de forma clara y legible grafos de objetos profundamente anidados sin riesgos relacionados con null.

var order = GetOrder(id);

// Deeply nested with fallbacks:
string countryCode = order
    ?.Customer
    ?.ShippingAddress
    ?.Country
    ?.Code
    ?? "US";

// Collection safe access:
decimal firstLineTotal = order
    ?.Lines
    ?.FirstOrDefault()
    ?.Total
    ?? 0m;

// Method chain:
string? trackingUpper = order?.TrackingNumber?.ToUpper().Trim();

Operador condicional de null en LINQ

El operador condicional de null funciona perfectamente con LINQ, lo que permite realizar consultas seguras sobre colecciones o propiedades que pueden ser null.

List<Order>? orders = customer?.Orders;

// Safe LINQ on a nullable collection:
var totalRevenue = orders?.Sum(o => o.Total) ?? 0m;
var pendingCount = orders?.Count(o => o.Status == OrderStatus.Pending) ?? 0;
var latest       = orders?.MaxBy(o => o.PlacedAt)?.Id;

Guardas contra null con ThrowIfNull

Para los parámetros que no deben ser null, use ArgumentNullException.ThrowIfNull() (.NET 6 o posterior) para realizar una validación concisa y descriptiva al entrar en el método.

public void ProcessOrder(Order order, Customer customer)
{
    ArgumentNullException.ThrowIfNull(order);
    ArgumentNullException.ThrowIfNull(customer);

    // From this point, compiler knows both are non-null
    Console.WriteLine(order.Id);
    Console.WriteLine(customer.Name);
}

// .NET 7+: ArgumentException.ThrowIfNullOrEmpty
void Save(string name)
{
    ArgumentException.ThrowIfNullOrWhiteSpace(name);
    // name is guaranteed non-empty
}

Patrón Is Not Null en Switch

La coincidencia de patrones con is not null y is { } proporciona patrones claros para comprobar null, especialmente en expresiones switch.

string Describe(object? obj) => obj switch
{
    null                          => "nothing",
    string s when s.Length == 0  => "empty string",
    string s                      => $"string: {s}",
    int i                         => $"integer: {i}",
    { }                           => $"object: {obj.GetType().Name}"
};

// is not null in if statements:
if (order is not null && order.Customer is { Name: var name })
    Console.WriteLine(name);

Comprobación rápida

¿Qué devuelve la expresión user?.Name ?? "Anonymous" cuando user es null?

Resumen: operadores condicionales y de fusión de null

Conceptos clave:

  • ?.: acceso seguro a miembros; devuelve null en lugar de producir una excepción cuando el receptor es null
  • ?[]: acceso seguro mediante índice a colecciones que pueden ser null
  • ??: valor alternativo cuando el operando izquierdo es null
  • ??=: asigna únicamente si el valor es null; ideal para la inicialización diferida
  • Encadénelos: a?.B?.C ?? defaultVal permite recorrer estructuras anidadas sin riesgos relacionados con null
  • ArgumentNullException.ThrowIfNull() para validar parámetros mediante guardas

Preguntas frecuentes

¿La lección «Operadores null-conditional y null-coalescing» es gratis?

Sí — el texto completo de «Operadores null-conditional y null-coalescing» 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 «Operadores null-conditional y null-coalescing»?

Combine ?., ?[], ?? y ??= para escribir código conciso y seguro frente a null sin comprobaciones de nulidad extensas. 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 «Operadores null-conditional y null-coalescing»?

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

  1. Activación y comprensión de NRT
  2. Anotaciones: ?, !, MaybeNull y NotNull
  3. Operadores null-conditional y null-coalescing
  4. Migración de una base de código a NRT
← Volver a C# Academy