L'operatore condizionale nullo C# 6 non funziona per la query LINQ

Question

Mi aspettavo che funzionasse, ma apparentemente il modo in cui l'IL genera, genera NullReferenceException. Perché il compilatore non può generare un codice simile per le query?

Nel caso ThisWorks, il compilatore genera codice che cortocircuita il resto dell'espressione, perché non può fare la stessa cosa per il caso di query LINQ?

class Target 
{ 
    public ChildTarget Child; 
} 

class ChildTarget 
{ 
    public int[] Values; 
} 

IEnumerable<int> ThisWorks(Target target) => 
    target.Child?.Values.Select(x => x); 

IEnumerable<int> ThisDoesNotWork(Target target) => 
    from x in target.Child?.Values select x; 

ThisWorks(new Target()); 
ThisDoesNotWork(new Target()); // this throws NullReferenceException 

decompilato risultati

private static IEnumerable<int> ThisDoesNotWork(Target target) 
{ 
    ChildTarget child = target.Child; 
    IEnumerable<int> values = (child != null) ? child.Values : null; 
    Func<int, int> func; 
    if ((func = Program._func) == null) 
    { 
     func = (Program._func = new Func<int, int>(Program._funcMethod)); 
    } 
    return values.Select(func); 
} 

private static IEnumerable<int> ThisWorks(Target target) 
{ 
    ChildTarget child = target.Child; 
    IEnumerable<int> values; 
    if (child == null) 
    { 
     values = null; 
    } 
    else 
    { 
     IEnumerable<int> values = child.Values; 
     Func<int, int> func; 
     if ((func = Program._func2) == null) 
     { 
      func = (Program._func2= new Func<int, int>(Program._funcMethod2)); 
     } 
     values = values.Select(func); 
    } 
    return values; 
} 

Answer 1

La risposta è nella specifica del linguaggio C#, che dice

un'espressione di query della forma

da x in e selezionare x

viene tradotto in

(e). Selezionare (x =>x)

Nota le parentesi intorno e nell'ultima riga. Ciò mostra chiaramente che l'espressione condizionale nulla (nel tuo esempio) finisce prima che venga chiamato Select, il che significa che Select potrebbe essere chiamato con il risultato nullo.

Perché non può fare la stessa cosa per Linq? Perché non è così che la funzione è stata progettata per funzionare. Le specifiche per gli operatori null-condizionali non hanno un caso speciale per le query, né viceversa.