Y a-t-il un «opposé» à l'opérateur de fusion nul? (… Dans n'importe quelle langue?)

la fusion nulle se traduit à peu près par return x, unless it is null, in which case return y

J'ai souvent besoin return null if x is null, otherwise return x.y

je peux utiliser return x == null ? null : x.y;

Pas mal, mais cela nullme dérange toujours au milieu - cela semble superflu. Je préférerais quelque chose comme return x :: x.y;, où ce qui suit ::est évalué uniquement si ce qui précède ne l'est pas null.

Je vois cela comme presque l'opposé de la coalescence nulle, en quelque sorte mélangée à un contrôle nul en ligne, mais je suis [ presque ] certain qu'il n'y a pas d'opérateur de ce type en C #.

Y a-t-il d'autres langages qui ont un tel opérateur? Si oui, comment s'appelle-t-il?

(Je sais que je peux écrire une méthode pour cela en C #; j'utilise return NullOrValue.of(x, () => x.y);, mais si vous avez quelque chose de mieux, j'aimerais voir cela aussi.)

Il y a l' opérateur de déréférencement à sécurité nulle (?.) Dans Groovy ... Je pense que c'est ce que vous recherchez.

(Il est également appelé l' opérateur de navigation sécurisée .)

Par exemple:

homePostcode = person?.homeAddress?.postcode

Cela donnera null si person, person.homeAddressou person.homeAddress.postcodeest nul.

(Ceci est maintenant disponible en C # 6.0 mais pas dans les versions antérieures)

Nous avons envisagé d'ajouter?. à C # 4. Il n'a pas fait la coupe; c'est une fonctionnalité "agréable à avoir", pas une fonctionnalité "à avoir". Nous y reviendrons pour de futures versions hypothétiques de la langue, mais je ne retiendrais pas mon souffle si j'étais vous. Il est peu probable que cela devienne plus crucial avec le temps. :-)

Si vous avez un type spécial de logique booléenne de court-circuit, vous pouvez le faire (exemple javascript):

return x && x.y;

Si xest nul, alors il ne sera pas évalué x.y.

Il me semblait juste d'ajouter ceci comme réponse.

Je suppose que la raison pour laquelle il n'y a rien de tel en C # est que, contrairement à l'opérateur de fusion (qui n'est valide que pour les types de référence), l'opération inverse pourrait donner un type de référence ou de valeur (c'est- class xà- dire avec membre int y- donc ce serait malheureusement inutilisable dans de nombreuses situations.

Je ne dis pas, cependant, que je n'aimerais pas le voir!

Une solution potentielle à ce problème serait que l'opérateur lève automatiquement une expression de type valeur sur le côté droit vers une valeur Nullable. Mais alors vous avez le problème que x.yoù y est un entier retournera en fait un int?qui serait pénible.

Une autre solution, probablement meilleure, serait que l'opérateur renvoie la valeur par défaut (c'est-à-dire null ou zéro) pour le type sur le côté droit si l'expression sur la gauche est nulle. Mais ensuite, vous rencontrez des problèmes pour distinguer les scénarios dans lesquels un zéro / null a été lu x.you s'il a été fourni par l'opérateur d'accès sécurisé.

Delphi a l'opérateur: (plutôt que.), Qui est de sécurité null.

Ils pensaient ajouter un?. opérateur à C # 4.0 pour faire de même, mais cela a obtenu le bloc de hachage.

En attendant, il y a IfNotNull () qui sorte de rayures qui démangent. C'est certainement plus grand que?. ou:, mais cela vous permet de composer une chaîne d'opérations qui ne gênera pas une NullReferenceException si l'un des membres est nul.

Dans Haskell, vous pouvez utiliser l' >>opérateur:

• Nothing >> Nothing est Nothing
• Nothing >> Just 1 est Nothing
• Just 2 >> Nothing est Nothing
• Just 2 >> Just 1 est Just 1

Haskell a fmap, ce qui dans ce cas, je pense, équivaut à Data.Maybe.map. Haskell est purement fonctionnel, donc ce que vous recherchez serait

fmap select_y x

Si xc'est le cas Nothing, cela revient Nothing. Si xc'est le cas Just object, cela revient Just (select_y object). Pas aussi joli que la notation par points, mais étant donné qu'il s'agit d'un langage fonctionnel, les styles sont différents.

PowerShell vous permet de référencer des propriétés (mais pas d'appeler des méthodes) sur une référence null et il renverra null si l'instance est null. Vous pouvez le faire à n'importe quelle profondeur. J'avais espéré que la fonctionnalité dynamique de C # 4 prendrait en charge cela, mais ce n'est pas le cas.

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

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

Ce n'est pas joli mais vous pouvez ajouter une méthode d'extension qui fonctionnera comme vous le décrivez.

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

J'ai souvent besoin de cette logique pour les chaînes:

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"

Créez une instance statique de votre classe quelque part avec toutes les bonnes valeurs par défaut pour les membres.

Par exemple:

z = new Thingy { y=null };

alors au lieu de ton

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

tu peux écrire

return (x ?? z).y;

Cela est ajouté dans C # vNext (Roslyn powered C #, versions avec Visual Studio 2014).

Il est appelé propagation Null et est répertorié ici comme complet. https://roslyn.codeplex.com/wikipage?title=Language%20Feature%20Status

Il est également répertorié ici comme complet: https://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/3990187-add-operator-to-c

Le soi-disant «opérateur conditionnel nul» a été introduit dans C # 6.0 et Visual Basic 14.
Dans de nombreuses situations, il peut être utilisé comme l'opposé exact de l'opérateur de fusion 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