¿Hay un" opuesto " al operador coalescente nulo? (any en cualquier idioma?)

¿Consideramos agregar?. a C # 4. No hizo el corte; es una característica de" agradable tener", no una característica de" tengo que tener". Lo consideraremos de nuevo para futuras versiones hipotéticas del idioma, pero no aguantaría la respiración esperando si fuera tú. No es probable que se vuelva más crucial a medida que pasa el tiempo. :-)

Si tienes un tipo especial de lógica booleana de cortocircuito, puedes hacer esto (ejemplo de javascript):

return x && x.y;

Si x es null, entonces no evaluará x.y.

Simplemente se sintió bien agregar esto como una respuesta.

Supongo que la razón por la que no hay tal cosa en C# es porque, a diferencia del operador coalescente (que solo es válido para tipos de referencia), la operación inversa podría producir un tipo de referencia o valor (es decir, class x con miembro int y - por lo tanto, desafortunadamente sería inutilizable en muchas situaciones.

No estoy diciendo, sin embargo, que no me gustaría verlo!

Una posible solución a ese problema sería para el operador para levantar automáticamente una expresión de tipo valor en el lado derecho a un valor nullable. Pero entonces tienes el problema de que x.y donde y es un int realmente devolverá un int? que sería un dolor.

Otra solución, probablemente mejor, sería que el operador devuelva el valor predeterminado (es decir, null o cero) para el tipo en el lado derecho si la expresión de la izquierda es null. Pero entonces tienes problemas para distinguir escenarios donde un cero/null fue leído de x.y o si fue suministrado por el operador de acceso seguro.

Delphi tiene: (en lugar de .) operador, que es nulo-seguro.

Estaban pensando en agregar a ?. operator to C # 4.0 to do the same, but that got the chopping block.

Mientras tanto, hay IfNotNull () que tipo de rasguños que pican. Es ciertamente más grande que ?. o:, pero te permite componer una cadena de operaciones que no te dará una excepción NullReferenceException si uno de los miembros es null.

En Haskell, puedes usar el operador >>:

• Nothing >> Nothing es Nothing
• Nothing >> Just 1 es Nothing
• Just 2 >> Nothing es Nothing
• Just 2 >> Just 1 es Just 1

Haskell tiene fmap, que en este caso creo que es equivalente aData.Maybe.map. Haskell es puramente funcional, por lo que lo que está buscando sería

fmap select_y x

Si x es Nothing, esto devuelve Nothing. Si x es Just object, esto devuelve Just (select_y object). No es tan bonito como la notación de puntos, pero dado que es un lenguaje funcional, los estilos son diferentes.

PowerShell le permite hacer referencia a propiedades (pero no a métodos) en una referencia null y devolverá null si la instancia es null. Puedes hacer esto a cualquier profundidad. Esperaba que la característica dinámica de C# 4 soportara esto, pero no lo hace.

$x = $null
$result = $x.y  # $result is null

$x = New-Object PSObject
$x | Add-Member NoteProperty y 'test'
$result = $x.y  # $result is 'test'

No es bonito, pero podría agregar un método de extensión que funcionará de la manera que describe.

public static TResult SafeGet<T, TResult>(this T obj, Func<T, TResult> selector) {
    if (obj == null) { return default(TResult); }
    else { return selector(obj); }
}

var myClass = new MyClass();
var result = myClass.SafeGet(x=>x.SomeProp);

Cree una instancia estática de su clase en algún lugar con todos los valores predeterminados correctos para los miembros.

Por ejemplo:

z = new Thingy { y=null };

Entonces en lugar de su

return x != null ? x.y : null;

Puedes escribir

return (x ?? z).y;

public class ok<T> {
    T s;
    public static implicit operator ok<T>(T s) { return new ok<T> { s = s }; }
    public static implicit operator T(ok<T> _) { return _.s; }

    public static bool operator true(ok<T> _) { return _.s != null; }
    public static bool operator false(ok<T> _) { return _.s == null; }
    public static ok<T> operator &(ok<T> x, ok<T> y) { return y; }
}

A menudo necesito esta lógica para cadenas:

using ok = ok<string>;

...

string bob = null;
string joe = "joe";

string name = (ok)bob && bob.ToUpper();   // name == null, no error thrown
string boss = (ok)joe && joe.ToUpper();   // boss == "JOE"

Esto se está agregando en C# vNext (Roslyn powered C#, versiones con Visual Studio 2014).

Se llama Propagación nula y se enumera aquí como completa. https://roslyn.codeplex.com/wikipage?title=Language%20Feature%20Status

También aparece aquí como completo: https://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/3990187-add-operator-to-c

El llamado "operador condicional nulo" ha sido introducido en C# 6.0 y en Visual Basic 14.
En muchas situaciones se puede utilizar como el opuesto exacto del operador null-coalescing:

int? length = customers?.Length; // null if customers is null   
Customer first = customers?[0];  // null if customers is null  
int? count = customers?[0]?.Orders?.Count();  // null if customers, the first customer, or Orders is null

Https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/null-conditional-operators