Est-ce qu'un opérateur conditionnel de référence est une bonne chose en C#?

Question

Dans les langages fonctionnels, il existe souvent une monade Maybe qui vous permet d'enchaîner plusieurs appels sur un objet et de renvoyer l'expression entière None/null si une partie de la chaîne n'évalue rien, plutôt que les NullReferenceException typiques que vous obtiendriez C# en enchaînant les appels où un objet pourrait être nul. Cela peut être implémenté de manière triviale en écrivant un Maybe<T> avec des méthodes d'extension pour permettre un comportement similaire en C# en utilisant des requêtes compréhensibles, ce qui peut être utile lors du traitement de XML avec des éléments/attributs facultatifs, par ex.

var val = from foo in doc.Elements("foo").FirstOrDefault().ToMaybe() 
      from bar in foo.Attribute("bar").ToMaybe() 
      select bar.Value; 

Mais cette syntaxe est un peu maladroit et peu intuitive que les gens sont habitués à traiter avec des séquences en Linq plutôt que des éléments simples, et il vous laisse avec un Maybe<T> plutôt qu'un T à la fin. Est-ce qu'un opérateur conditionnel de référence (par exemple ..) être suffisamment utile pour en faire la langue? par exemple.

var val = doc.Elements("foo").FirstOrDefault()..Attribute("bar")..Value; 

Le de référence conditionnelle se développerait à quelque chose comme:

object val; 
var foo = doc.Elements("foo").FirstOrDefault(); 
if (foo != null) 
{ 
    var bar = foo.Attribute("bar"); 
    if (bar != null) 
    { 
     val = bar.Value; 
    } 
    else 
    { 
     val = null; 
    } 
} 

Je peux voir que cela pourrait conduire à des abus terribles comme l'utilisation .. partout pour éviter une NullReferenceException, mais d'autre part lorsqu'il est utilisé correctement, il pourrait être très utile dans un certain nombre de situations. Pensées?

Answer 1

Chaînage plusieurs appels sur un objet me fait craindre des violations du Law of Demeter. Ainsi, je suis sceptique que cette fonctionnalité est une bonne idée, au moins en termes de résolution du problème spécifique que vous utilisez comme exemple.

Answer 2

Il est une idée intéressante qui pourrait être réalisée avec une méthode d'extension. Quelque chose comme ça, par exemple (note, il suffit par exemple - je suis sûr qu'il peut être affiné):

public static IEnumerable<T> Maybe<T>(this IEnumerable<T> lhs, Func<IEnumerable<T>, T> rhs) 
{ 
    if (lhs != null) 
    { 
    return rhs(lhs); 
    } 

    return lhs; 
} 

Answer 3

Je soupçonne une combinaison de NULLABLE et des méthodes d'extension permettrait à une partie importante de ce à b atteint.

Cela limiterait T aux types de valeur bien sûr.

(TBH Je préférerais voir le soutien de tuple dans le langauge et éliminer les paramètres out, comme F # fait.)

Code Vous pouvez être simplifié, val null définir et vous éliminer les branches d'autre.

Answer 4

Je peux voir l'utilité potentielle, mais autre qu'un léger impact sur les performances si les éléments sont souvent nuls, pourquoi ne pas simplement entourer le bloc de code avec un bloc try..catch pour une exception NullReferenceException?