C# Language
Operadores de condicionamiento nulo

Sintaxis

• X? .Y; // nulo si X es nulo o XY
• X? .Y? .Z; // nulo si X es nulo o Y es nulo o XYZ
• X? [Índice]; // nulo si X es nulo otra cosa X [índice]
• X? .ValueMethod (); // nulo si X es nulo o el resultado de X.ValueMethod ();
• X? .VoidMethod (); // no hacer nada si X es nulo o llama a X.VoidMethod ();

Observaciones

Operador condicional nulo

El ?. El operador es el azúcar sintáctico para evitar verificaciones nulas verbosas. También es conocido como el operador de navegación segura .

Clase utilizada en el siguiente ejemplo:

public class Person
{
    public int Age { get; set; }
    public string Name { get; set; }
    public Person Spouse { get; set; }
}

Si un objeto es potencialmente nulo (como una función que devuelve un tipo de referencia), primero se debe verificar si el objeto es nulo para evitar una posible NullReferenceException . Sin el operador condicional nulo, esto se vería así:

Person person = GetPerson();

int? age = null;
if (person != null)
    age = person.Age;

El mismo ejemplo usando el operador condicional nulo:

Person person = GetPerson();

var age = person?.Age;    // 'age' will be of type 'int?', even if 'person' is not null

Encadenamiento del operador

El operador condicional nulo se puede combinar en los miembros y sub-miembros de un objeto.

// Will be null if either `person` or `person.Spouse` are null
int? spouseAge = person?.Spouse?.Age;

Combinando con el Operador Nulo-Coalescente

El operador de condición nula se puede combinar con el operador de unión nula para proporcionar un valor predeterminado:

// spouseDisplayName will be "N/A" if person, Spouse, or Name is null
var spouseDisplayName = person?.Spouse?.Name ?? "N/A";

El índice nulo condicional

Al igual que el ?. operador, el operador de índice condicional nulo verifica los valores nulos al indexar en una colección que puede ser nula.

string item = collection?[index];

es azúcar sintáctica para

string item = null;
if(collection != null)
{
    item = collection[index];
}

Evitando NullReferenceExceptions

var person = new Person
{
    Address = null;
};

var city = person.Address.City; //throws a NullReferenceException
var nullableCity = person.Address?.City; //returns the value of null

Este efecto puede ser encadenado:

var person = new Person
{
    Address = new Address
    {
        State = new State
        {
            Country = null
        }
    }
};

// this will always return a value of at least "null" to be stored instead
// of throwing a NullReferenceException
var countryName = person?.Address?.State?.Country?.Name; 

El operador condicional nulo se puede utilizar con el método de extensión

El método de extensión puede funcionar en referencias nulas , pero puede usar ?. para nulo-comprobar de todos modos.

public class Person 
{
    public string Name {get; set;}
}

public static class PersonExtensions
{
    public static int GetNameLength(this Person person)
    {
        return person == null ? -1 : person.Name.Length;
    }
}

Normalmente, el método se activará para referencias null y devolverá -1:

Person person = null;
int nameLength = person.GetNameLength(); // returns -1

Utilizando ?. el método no se activará para referencias null , y el tipo es int? :

Person person = null;
int? nameLength = person?.GetNameLength(); // nameLength is null.

Este comportamiento se espera realmente de la forma en que el ?. el operador funciona: evitará realizar llamadas de método de instancia para instancias nulas, para evitar NullReferenceExceptions . Sin embargo, la misma lógica se aplica al método de extensión, a pesar de la diferencia en cómo se declara el método.

Para obtener más información sobre por qué se llama al método de extensión en el primer ejemplo, consulte los Métodos de extensión: documentación de comprobación nula .