Un operatore di de-riferimento condizionale sarebbe una buona cosa in C#?

Question

Nei linguaggi funzionali c'è spesso un monad Maybe che consente di concatenare più chiamate su un oggetto e restituire l'intera espressione None/null se nessuna parte della catena restituisce nulla, piuttosto che il tipico NullReferenceException che si ottiene C# concatenando le chiamate in cui un oggetto potrebbe essere nullo.

Questo può essere banalmente implementato crei una Maybe<T> con alcuni metodi di estensione per consentire comportamento simile in C# utilizzando comprehensions query, che può essere utile quando si elaborano XML con elementi facoltativi/attributi esempio

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

Ma questa sintassi è un po 'goffo e poco intuitivo come le persone sono abituate a trattare con le sequenze in LINQ, piuttosto che singoli elementi, e ti lascia con un Maybe<T> piuttosto che un T alla fine. Un operatore di de-riferimento condizionale (ad es. ..) sarebbe sufficientemente utile per farlo entrare nella lingua? per esempio.

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

Il condizionale de-riferimento si espanderebbe a qualcosa di simile:

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

posso vedere che questo potrebbe potenzialmente portare a terribili abusi come l'utilizzo di .. ovunque per evitare una NullReferenceException, ma d'altra parte se usato correttamente potrebbe essere molto utile in diverse situazioni. Pensieri?

Answer 1

Concatenare più chiamate su un oggetto mi fa temere violazioni dello Law of Demeter. Pertanto, sono scettico sul fatto che questa funzione sia una buona idea, almeno in termini di risoluzione del problema specifico che stai usando come esempio.

Answer 2

È un'idea interessante che è possibile ottenere con un metodo di estensione. Qualcosa di simile, per esempio (si noti, solo per esempio - sono sicuro che può essere raffinato):

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

Ho il sospetto che una combinazione di Nullable e metodi di estensione permetterebbe una porzione significativa di questo a B raggiunto.

Ciò limiterà T a tipi di valore, naturalmente.

(TBH Avrei preferito vedere il supporto tuple nel langauge ed eliminare i punti principali, come F # fa.)

codice è possibile essere semplificata, impostare val di nulla e si eliminano i rami altro.

Answer 4

Posso vedere l'utilità potenziale, ma a parte un leggero impatto sulle prestazioni se gli elementi sono spesso nulli, perché non circondare semplicemente il blocco di codice con un blocco try..catch per una NullReferenceException?