C# Language
Operador de unión nula
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"));
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
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
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
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 ) );