Gibt es ein "Gegenteil" zum Null-Koaleszenz-Operator? (… In irgendeiner Sprache?)

Null-Koaleszenz bedeutet ungefähr return x, unless it is null, in which case return y

Ich brauche oft return null if x is null, otherwise return x.y

ich kann nutzen return x == null ? null : x.y;

Nicht schlecht, aber das nullin der Mitte stört mich immer - es scheint überflüssig. Ich würde so etwas bevorzugen return x :: x.y;, wo das, was folgt ::, nur ausgewertet wird, wenn das, was davor steht, nicht ausgewertet wird null.

Ich sehe dies fast als das Gegenteil von Null-Koaleszenz, gemischt mit einem knappen Inline-Null-Check, aber ich bin [ fast] ] sicher, dass es in C # keinen solchen Operator gibt.

Gibt es andere Sprachen, die einen solchen Operator haben? Wenn ja, wie heißt es?

(Ich weiß, dass ich eine Methode dafür in C # schreiben kann; ich verwende return NullOrValue.of(x, () => x.y);, aber wenn Sie etwas Besseres haben, würde ich das auch gerne sehen.)

Es gibt den nullsicheren DereferenzierungsoperatorIn Groovy (?.) ... Ich denke, das ist es, wonach Sie suchen.

(Es wird auch als sicherer Navigationsoperator bezeichnet .)

Beispielsweise:

homePostcode = person?.homeAddress?.postcode

Dies ergibt null, wenn person,person.homeAddress oder person.homeAddress.postcodeist null.

(Dies ist jetzt in C # 6.0 verfügbar, jedoch nicht in früheren Versionen.)

Wir haben darüber nachgedacht,? zu C # 4. Es hat den Schnitt nicht geschafft; Es ist eine "nice to have" -Funktion, keine "gotta have" -Funktion. Wir werden es für hypothetische zukünftige Versionen der Sprache noch einmal in Betracht ziehen, aber ich würde nicht den Atem anhalten und warten, wenn ich Sie wäre. Mit der Zeit wird es wahrscheinlich nicht mehr entscheidend. :-)

Wenn Sie eine spezielle Art von boolescher Kurzschlusslogik haben, können Sie dies tun (Javascript-Beispiel):

return x && x.y;

Wenn xnull ist, wird es nicht ausgewertet x.y.

Es fühlte sich einfach richtig an, dies als Antwort hinzuzufügen.

Ich denke, der Grund, warum es so etwas in C # nicht gibt, liegt darin, dass die umgekehrte Operation im Gegensatz zum Koaleszenzoperator (der nur für Referenztypen gültig ist) entweder einen Referenz- oder einen Werttyp (dh class xmit Mitglied) ergeben könnteint y - daher wäre dies leider der Fall in vielen Situationen unbrauchbar.

Ich sage jedoch nicht, dass ich es nicht sehen möchte!

Eine mögliche Lösung für dieses Problem wäre, dass der Bediener einen Werttypausdruck auf der rechten Seite automatisch auf null setzt. Aber dann haben Sie das Problem, dass, x.ywenn y ein int ist, tatsächlich ein zurückgegeben wirdint? was ein Schmerz wäre.

Eine andere, wahrscheinlich bessere Lösung wäre, dass der Operator den Standardwert (dh null oder null) für den Typ auf der rechten Seite zurückgibt, wenn der Ausdruck auf der linken Seite null ist. Aber dann haben Sie Probleme bei der Unterscheidung von Szenarien, aus denen tatsächlich eine Null / Null gelesen wurde x.yoder ob sie vom Operator für sicheren Zugriff bereitgestellt wurde.

Delphi hat den Operator: (anstatt.), Der nullsicher ist.

Sie dachten darüber nach, ein? Operator auf C # 4.0, um dasselbe zu tun, aber das hat den Hackklotz bekommen.

In der Zwischenzeit gibt es IfNotNull (), welche Art von Kratzern juckt . Es ist sicherlich größer als? oder :, aber Sie können damit eine Kette von Operationen erstellen, die keine NullReferenceException bei Ihnen verursachen, wenn eines der Mitglieder null ist.

In Haskell können Sie den >>Operator verwenden:

• Nothing >> Nothing ist Nothing
• Nothing >> Just 1 ist Nothing
• Just 2 >> Nothing ist Nothing
• Just 2 >> Just 1 ist Just 1

Haskell hat fmap, was in diesem Fall meiner Meinung nach gleichwertig ist Data.Maybe.map. Haskell ist rein funktional, also was Sie suchen, wäre

fmap select_y x

Wenn xist Nothing, diese zurückkehrt Nothing. Wenn xist Just object, diese zurückkehrt Just (select_y object). Nicht so hübsch wie die Punktnotation, aber da es sich um eine funktionale Sprache handelt, sind die Stile unterschiedlich.

Mit PowerShell können Sie Eigenschaften (aber keine Aufrufmethoden) für eine Nullreferenz referenzieren. Wenn die Instanz null ist, wird null zurückgegeben. Sie können dies in jeder Tiefe tun. Ich hatte gehofft, dass die dynamische Funktion von C # 4 dies unterstützen würde, aber dies ist nicht der Fall.

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

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

Es ist nicht schön, aber Sie könnten eine Erweiterungsmethode hinzufügen, die so funktioniert, wie Sie es beschreiben.

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

Ich brauche diese Logik oft für 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"

Erstellen Sie irgendwo eine statische Instanz Ihrer Klasse mit den richtigen Standardwerten für die Mitglieder.

Beispielsweise:

z = new Thingy { y=null };

dann statt deiner

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

Du kannst schreiben

return (x ?? z).y;

Dies wird in C # vNext hinzugefügt (Roslyn powered C #, Releases mit Visual Studio 2014).

Es heißt Null-Propagation und wird hier als vollständig aufgeführt. https://roslyn.codeplex.com/wikipage?title=Language%20Feature%20Status

Es wird auch hier als vollständig aufgeführt: https://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/3990187-add-operator-to-c

Der sogenannte "nullbedingte Operator" wurde in C # 6.0 und in Visual Basic 14 eingeführt.
In vielen Situationen kann er als genaues Gegenteil des nullkoaleszierenden Operators verwendet werden:

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