Existe um “oposto” ao operador de coalescência nulo? (... em qualquer idioma?)

coalescência nula se traduz aproximadamente em return x, unless it is null, in which case return y

Eu frequentemente preciso return null if x is null, otherwise return x.y

Eu posso usar return x == null ? null : x.y;

Não é ruim, mas isso nullno meio sempre me incomoda - parece supérfluo. Eu prefiro algo como return x :: x.y;, onde o que vem depois de ::é avaliado apenas se o que vem antes não é null.

Eu vejo isso como quase o oposto da coalescência nula, meio que misturada com uma verificação nula em linha e concisa, mas estou [ quase ] certo de que não existe tal operador em C #.

Existem outras linguagens que possuem esse operador? Se sim, como é chamado?

(Eu sei que posso escrever um método para ele em C #; eu uso return NullOrValue.of(x, () => x.y);, mas se você tiver algo melhor, gostaria de ver isso também.)

Existe o operador de desreferenciação null-safe (?.) No Groovy ... Acho que é isso que você quer.

(Também é chamado de operador de navegação segura .)

Por exemplo:

homePostcode = person?.homeAddress?.postcode

Isso dará nulo se person, person.homeAddressou person.homeAddress.postcodefor nulo.

(Isso agora está disponível em C # 6.0, mas não em versões anteriores)

Nós consideramos adicionar?. para C # 4. Não fez o corte; é um recurso "bom ter", não um recurso "preciso ter". Vamos considerá-lo novamente para hipotéticas versões futuras do idioma, mas eu não prenderia a respiração esperando se fosse você. Não é provável que se torne mais crucial com o passar do tempo. :-)

Se você tiver um tipo especial de lógica booleana de curto-circuito, poderá fazer isso (exemplo de javascript):

return x && x.y;

Se xfor nulo, não será avaliado x.y.

Parecia certo adicionar isso como uma resposta.

Eu acho que a razão pela qual não existe tal coisa em C # é porque, ao contrário do operador de coalescência (que é válido apenas para tipos de referência), a operação reversa pode render uma referência ou um tipo de valor (ou seja, class xcom membro int y- portanto, infelizmente seria inutilizável em muitas situações.

Não estou dizendo, porém, que não gostaria de ver isso!

Uma solução potencial para esse problema seria o operador elevar automaticamente uma expressão de tipo de valor no lado direito para um valor anulável. Mas então você tem o problema de que x.yonde y é um int, na verdade retornará um int?que seria uma dor.

Outra solução, provavelmente melhor, seria o operador retornar o valor padrão (ou seja, nulo ou zero) para o tipo do lado direito se a expressão à esquerda for nula. Mas então você tem problemas para distinguir cenários onde um zero / nulo foi realmente lido x.you se foi fornecido pelo operador de acesso seguro.

O Delphi tem o operador: (em vez de.), Que é seguro para nulos.

Eles estavam pensando em adicionar um?. operador para C # 4.0 para fazer o mesmo, mas isso pegou o bloco de corte.

Nesse ínterim, há IfNotNull () que tipo de coça essa coceira. Certamente é maior do que?. ou:, mas permite que você componha uma cadeia de operações que não exigirá uma NullReferenceException para você se um dos membros for nulo.

Em Haskell, você pode usar o >>operador:

• Nothing >> Nothing é Nothing
• Nothing >> Just 1 é Nothing
• Just 2 >> Nothing é Nothing
• Just 2 >> Just 1 é Just 1

Haskell tem fmap, que neste caso eu acho que é equivalente a Data.Maybe.map. Haskell é puramente funcional, então o que você está procurando seria

fmap select_y x

Se xfor Nothing, isso retorna Nothing. Se xfor Just object, isso retorna Just (select_y object). Não é tão bonito quanto a notação de ponto, mas por ser uma linguagem funcional, os estilos são diferentes.

O PowerShell permite que você faça referência a propriedades (mas não a métodos de chamada) em uma referência nula e retornará nulo se a instância for nula. Você pode fazer isso em qualquer profundidade. Eu esperava que o recurso dinâmico do C # 4 fosse compatível com isso, mas não é.

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

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

Não é bonito, mas você pode adicionar um método de extensão que funcione da maneira que você descreve.

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

Freqüentemente preciso desta lógica para strings:

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"

Crie uma instância estática de sua classe em algum lugar com todos os valores padrão corretos para os membros.

Por exemplo:

z = new Thingy { y=null };

então em vez de seu

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

você pode escrever

return (x ?? z).y;

Isso está sendo adicionado no C # vNext (Roslyn desenvolvido com C #, lançamentos com Visual Studio 2014).

É chamado de propagação nula e é listado aqui como completo. https://roslyn.codeplex.com/wikipage?title=Language%20Feature%20Status

Também está listado aqui como completo: https://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/3990187-add-operator-to-c

O chamado "operador nulo-condicional" foi introduzido no C # 6.0 e no Visual Basic 14.
Em muitas situações, ele pode ser usado como o oposto exato do operador nulo-coalescente:

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