Esiste un "opposto" all'operatore di coalescenza nullo? (... in qualsiasi lingua?)

null coalescing si traduce approssimativamente in return x, unless it is null, in which case return y

Ho spesso bisogno return null if x is null, otherwise return x.y

posso usare return x == null ? null : x.y;

Non male, ma quello nullnel mezzo mi dà sempre fastidio - sembra superfluo. Preferirei qualcosa di simile return x :: x.y;, dove ciò che segue ::viene valutato solo se ciò che lo precede non lo è null.

Lo vedo quasi l'opposto della coalescenza nulla, un po 'mescolato con un controllo null inline conciso, ma sono [ quasi ] certo che non esiste un tale operatore in C #.

Esistono altre lingue che hanno un tale operatore? se è così, come è chiamato?

(So ​​che posso scrivere un metodo per questo in C #; lo uso return NullOrValue.of(x, () => x.y);, ma se hai qualcosa di meglio, mi piacerebbe vedere anche quello.)

C'è l' operatore di dereferenziazione null-safe (?.) In Groovy ... Penso che sia quello che stai cercando.

(È anche chiamato operatore di navigazione sicura .)

Per esempio:

homePostcode = person?.homeAddress?.postcode

Questo darà null se person, person.homeAddresso person.homeAddress.postcodeè null.

(Questo è ora disponibile in C # 6.0 ma non nelle versioni precedenti)

Abbiamo considerato l'aggiunta di?. a C # 4. Non ha fatto il taglio; è una funzione "carina da avere", non una funzione "da avere". Lo prenderemo in considerazione di nuovo per ipotetiche versioni future del linguaggio, ma non terrei il respiro in attesa se fossi in te. Non è probabile che diventi più cruciale col passare del tempo. :-)

Se hai un tipo speciale di logica booleana di cortocircuito, puoi farlo (esempio javascript):

return x && x.y;

Se xè nullo, non verrà valutato x.y.

Mi è sembrato giusto aggiungere questo come risposta.

Immagino che il motivo per cui non esiste nulla di simile in C # è perché, a differenza dell'operatore di coalescenza (che è valido solo per i tipi di riferimento), l'operazione inversa potrebbe produrre un tipo di riferimento o di valore (cioè class xcon membro int y- quindi sarebbe sfortunatamente inutilizzabile in molte situazioni.

Non dico però che non mi piacerebbe vederlo!

Una potenziale soluzione a questo problema sarebbe che l'operatore elevasse automaticamente un'espressione del tipo di valore sul lato destro a un nullable. Ma poi hai il problema che x.ydove y è un int restituirà effettivamente un int?che sarebbe un dolore.

Un'altra soluzione, probabilmente migliore, sarebbe che l'operatore restituisse il valore predefinito (cioè null o zero) per il tipo sul lato destro se l'espressione a sinistra è null. Ma poi hai problemi a distinguere gli scenari in cui uno zero / null è stato effettivamente letto x.yo se è stato fornito dall'operatore di accesso sicuro.

Delphi ha l'operatore: (invece di.), Che è null-safe.

Stavano pensando di aggiungere un?. operatore in C # 4.0 per fare lo stesso, ma questo ha ottenuto il blocco.

Nel frattempo, c'è IfNotNull () che tipo di graffi che prude. È certamente più grande di?. oppure:, ma ti consente di comporre una catena di operazioni che non genereranno un'eccezione NullReferenceException se uno dei membri è nullo.

In Haskell, puoi usare il >> operatore:

• Nothing >> Nothing è Nothing
• Nothing >> Just 1 è Nothing
• Just 2 >> Nothing è Nothing
• Just 2 >> Just 1 è Just 1

Haskell ha fmap, che in questo caso penso sia equivalente a Data.Maybe.map. Haskell è puramente funzionale, quindi quello che stai cercando sarebbe

fmap select_y x

Se xè Nothing, questo ritorna Nothing. Se xè Just object, questo ritorna Just (select_y object). Non bella come la notazione a punti, ma dato che è un linguaggio funzionale, gli stili sono diversi.

PowerShell consente di fare riferimento alle proprietà (ma non ai metodi di chiamata) su un riferimento null e restituirà null se l'istanza è null. Puoi farlo a qualsiasi profondità. Avevo sperato che la funzionalità dinamica di C # 4 lo supportasse, ma non è così.

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

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

Non è carino ma potresti aggiungere un metodo di estensione che funzionerà nel modo in cui descrivi.

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

Spesso ho bisogno di questa logica per le stringhe:

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"

Crea un'istanza statica della tua classe da qualche parte con tutti i valori predefiniti corretti per i membri.

Per esempio:

z = new Thingy { y=null };

quindi invece del tuo

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

tu puoi scrivere

return (x ?? z).y;

Questo viene aggiunto in C # vNext (C # basato su Roslyn, versioni con Visual Studio 2014).

Si chiama propagazione nulla ed è elencato qui come completo. https://roslyn.codeplex.com/wikipage?title=Language%20Feature%20Status

È anche elencato qui come completo: https://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/3990187-add-operator-to-c

Il cosiddetto "operatore condizionale null" è stato introdotto in C # 6.0 e in Visual Basic 14.
In molte situazioni può essere utilizzato come l'esatto opposto dell'operatore di coalescenza null:

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