question operator operador mark empty diferente c# programming-languages syntax operators null-coalescing-operator

operator - operador null c#



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

Consideramos agregar? a C # 4. No hizo el corte; es una característica "agradable de tener", no una función "tengo que tener". Volveremos a considerarlo para versiones hipotéticas futuras del lenguaje, pero no dejaría de esperar si fuera usted. No es probable que se vuelva más crucial a medida que pasa el tiempo. :-)

nulo coalescente se traduce aproximadamente para return x, unless it is null, in which case return y

A menudo necesito return null if x is null, otherwise return xy

Puedo usar return x == null ? null : xy; return x == null ? null : xy;

No está mal, pero ese null en el medio siempre me molesta, parece superfluo. Prefiero algo como return x :: xy; , donde lo que sigue a :: se evalúa solo si lo que le precede no es null .

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

¿Hay otros idiomas que tengan dicho operador? Si es así, ¿cómo se llama?

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

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;

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

Estaban pensando en agregar un? operador a C # 4.0 para hacer lo mismo, pero que obtuvo la tabla de cortar.

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 afectará a una NullReferenceException si uno de los miembros es nulo.

El llamado "operador condicional nulo" se ha introducido en C # 6.0 y en Visual Basic 14.
En muchas situaciones, se puede usar como el opuesto exacto del operador de fusión nula:

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

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

fmap select_y x

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

PowerShell le permite hacer referencia a las propiedades (pero no a los métodos de llamada) en una referencia nula y devolverá nulo si la instancia es nula. Puedes hacerlo a cualquier profundidad. Esperaba que la característica dinámica de C # 4 respaldaría 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 podrías agregar un método de extensión que funcione de la manera que describes.

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);

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

return x && x.y;

Si x es nulo, entonces no evaluará xy .

Simplemente me pareció correcto agregar esto como una respuesta.

Supongo que la razón por la cual 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 generar un tipo de referencia o de valor (es decir, class x con miembro int y ; Desafortunadamente sería inutilizable en muchas situaciones.

¡No digo, sin embargo, que no me gustaría verlo!

Una posible solución a ese problema sería que el operador levante automáticamente una expresión de tipo de valor en el lado derecho a un valor nulable. ¿Pero entonces tienes el problema de que xy donde y es un int realmente devolverá un int? lo cual sería un dolor

Otra solución, probablemente mejor, sería que el operador devuelva el valor predeterminado (es decir, nulo o cero) para el tipo en el lado derecho si la expresión de la izquierda es nula. Pero luego tiene problemas para distinguir los escenarios en los que se leyó realmente un cero / nulo de xy o si fue suministrado por el operador de acceso seguro.

Está el operador de desreferenciación nulo-seguro (?.) En Groovy ... Creo que eso es lo que buscas.

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

Por ejemplo:

homePostcode = person?.homeAddress?.postcode

Esto dará null si la person , person.homeAddress o person.homeAddress.postcode es nula.

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

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"