Buscar..


Sintaxis

  • var result = possibleNullObject ?? valor por defecto;

Parámetros

Parámetro Detalles
possibleNullObject El valor para probar el valor nulo. Si no es nulo, se devuelve este valor. Debe ser un tipo anulable.
defaultValue El valor devuelto si es possibleNullObject NullObject es nulo. Debe ser del mismo tipo que possibleNullObject .

Observaciones

El operador de unión nula es dos caracteres de signo de interrogación consecutivos: ??

Es una abreviatura de la expresión condicional:

possibleNullObject != null ? possibleNullObject : defaultValue

El operando del lado izquierdo (objeto que se está probando) debe ser un tipo de valor anulable o un tipo de referencia, o se producirá un error de compilación.

Los ?? El operador trabaja tanto para tipos de referencia como para tipos de valor.

Uso básico

El uso del null-coalescing operator (??) permite especificar un valor predeterminado para un tipo anulable si el operando de la izquierda es null .

string testString = null;
Console.WriteLine("The specified string is - " + (testString ?? "not provided"));

Demo en vivo en .NET Fiddle

Esto es lógicamente equivalente a:

string testString = null;
if (testString == null)
{
    Console.WriteLine("The specified string is - not provided");
}
else
{
    Console.WriteLine("The specified string is - " + testString);
}

o utilizando el operador ternario (? :) operador:

string testString = null;
Console.WriteLine("The specified string is - " + (testString == null ? "not provided" : testString));

Nula caída y encadenamiento

El operando de la izquierda debe ser anulable, mientras que el operando de la derecha puede ser o no. El resultado se escribirá en consecuencia.

No nulable

int? a = null;
int b = 3;
var output = a ?? b;
var type = output.GetType();  

Console.WriteLine($"Output Type :{type}");
Console.WriteLine($"Output value :{output}");

Salida:

Tipo: System.Int32
valor: 3

Ver demostración

Anulable

int? a = null;
int? b = null;
var output = a ?? b;

output será de tipo int? e igual a b , o null .

Coalescente múltiple

La coalescencia también se puede hacer en cadenas:

int? a = null;
int? b = null;
int c = 3;
var output = a ?? b ?? c;

var type = output.GetType();    
Console.WriteLine($"Type :{type}");
Console.WriteLine($"value :{output}");

Salida:

Tipo: System.Int32
valor: 3

Ver demostración

Encadenamiento condicional nulo

El operador de unión nula se puede utilizar junto con el operador de propagación nula para proporcionar un acceso más seguro a las propiedades de los objetos.

object o = null;
var output = o?.ToString() ?? "Default Value";

Salida:

Tipo: System.String
valor: valor predeterminado

Ver demostración

Operador coalescente nulo con llamadas a método

El operador de unión nula facilita la tarea de garantizar que un método que pueda devolver null recaiga en un valor predeterminado.

Sin el operador de unión nula:

string name = GetName();

if (name == null)
    name = "Unknown!";

Con el operador de unión nula:

string name = GetName() ?? "Unknown!";

Usa existente o crea nuevo.

Un escenario de uso común con el que esta característica realmente ayuda es cuando busca un objeto en una colección y necesita crear uno nuevo si aún no existe.

IEnumerable<MyClass> myList = GetMyList();
var item = myList.SingleOrDefault(x => x.Id == 2) ?? new MyClass { Id = 2 };

Inicialización de propiedades diferidas con operador coalescente nulo

private List<FooBar> _fooBars;

public List<FooBar> FooBars
{
    get { return _fooBars ?? (_fooBars = new List<FooBar>()); }
}

La primera vez que se accede a la propiedad .FooBars la variable _fooBars se evaluará como null , por lo que _fooBars en la instrucción de asignación asigna y evalúa el valor resultante.

Seguridad del hilo

Esta no es una forma segura de implementar propiedades perezosas. Para la holgazanería segura, use la clase Lazy<T> integrada en .NET Framework.

C # 6 Azúcar sintáctico utilizando cuerpos de expresión.

Tenga en cuenta que desde C # 6, esta sintaxis se puede simplificar utilizando el cuerpo de la expresión para la propiedad:

private List<FooBar> _fooBars;

public List<FooBar> FooBars => _fooBars ?? ( _fooBars = new List<FooBar>() );

Los accesos posteriores a la propiedad producirán el valor almacenado en la variable _fooBars .

Ejemplo en el patrón MVVM

Esto se usa a menudo cuando se implementan comandos en el patrón MVVM. En lugar de inicializar los comandos con entusiasmo con la construcción de un modelo de vista, los comandos se inician perezosamente utilizando este patrón de la siguiente manera:

private ICommand _actionCommand = null;
public ICommand ActionCommand =>
   _actionCommand ?? ( _actionCommand = new DelegateCommand( DoAction ) );


Modified text is an extract of the original Stack Overflow Documentation
Licenciado bajo CC BY-SA 3.0
No afiliado a Stack Overflow