¿Existe un "opuesto" al operador coalescente nulo? (…¿en cualquier idioma?)

la coalescencia nula se traduce aproximadamente en return x, unless it is null, in which case return y

A menudo necesito return null if x is null, otherwise return x.y

Puedo usar return x == null ? null : x.y;

No está mal, pero eso nullen el medio siempre me molesta, parece superfluo. Preferiría algo como return x :: x.y;, donde lo que sigue a ::se evalúa solo si lo que le precede no lo es null.

Veo esto como casi un opuesto a la coalescencia nula, algo mezclado con una verificación nula en línea concisa, pero estoy [ casi ] seguro de que no existe tal operador en C #.

¿Hay otros idiomas que tengan un operador de este tipo? Si es así, ¿cómo se llama?

(Sé que puedo escribir un método para ello en C #; lo uso return NullOrValue.of(x, () => x.y);, pero si tienes algo mejor, me gustaría verlo también).

Ahí está el operador de desreferencia nula de fallos (?.) En el maravilloso ... Creo que eso es lo que está buscando.

(También se llama operador de navegación segura ).

Por ejemplo:

homePostcode = person?.homeAddress?.postcode

Esto dará nulo si person, person.homeAddresso person.homeAddress.postcodees nulo.

(Esto ahora está disponible en C # 6.0 pero no en versiones anteriores)

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

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

return x && x.y;

Si xes nulo, no se evaluará x.y.

Simplemente me pareció correcto agregar esto como respuesta.

Supongo que la razón por la que no existe 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 una referencia o un tipo de valor (es decir, class xcon miembro int y, por lo que desafortunadamente sería inutilizable en muchas situaciones.

Sin embargo, no estoy diciendo que no me gustaría verlo.

Una posible solución a ese problema sería que el operador elevara automáticamente una expresión de tipo de valor en el lado derecho a un valor anulable. Pero luego tiene el problema de que x.ydonde y es un int, en realidad devolverá un, lo int?que sería una molestia.

Otra solución, probablemente mejor, sería que el operador devolviera el valor predeterminado (es decir, nulo o cero) para el tipo del lado derecho si la expresión del lado izquierdo es nula. Pero luego tiene problemas para distinguir escenarios donde realmente se leyó un cero / nulo x.yo si fue proporcionado por el operador de acceso seguro.

Delphi tiene el operador: (en lugar de.), Que es seguro para nulos.

Estaban pensando en agregar un?. operador a C # 4.0 para hacer lo mismo, pero eso consiguió el bloque de corte.

Mientras tanto, hay IfNotNull () que tipo de rasguños pican. Ciertamente es más grande que ?. o:, pero le permite componer una cadena de operaciones que no le enviará una NullReferenceException si uno de los miembros es nulo.

En Haskell, puede utilizar 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 a Data.Maybe.map. Haskell es puramente funcional, así que lo que estás buscando sería

fmap select_y x

Si xes así Nothing, esto vuelve Nothing. Si xes así Just object, esto vuelve 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 de llamada) en una referencia nula y devolverá nulo si la instancia es nula. Puede hacer esto a cualquier profundidad. Tenía la esperanza de que la función dinámica de C # 4 fuera compatible con esto, pero no es así.

$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 puede agregar un método de extensión que funcione como lo 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);

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"

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 tu

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

puedes escribir

return (x ?? z).y;

Esto se está agregando en C # vNext (C # con tecnología de Roslyn, 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" se introdujo en C # 6.0 y en Visual Basic 14.
En muchas situaciones se puede utilizar como exactamente lo contrario del operador coalescente nulo:

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