Operatore '?' Non può essere applicato a operandi di tipo 'T'

Question

Cercando di fare Feature generico e poi improvvisamente compilatore detto

Operatore '?' Non può essere applicato a operandi di tipo 'T'

Ecco il codice

public abstract class Feature<T> 
{ 
    public T Value 
    { 
     get { return GetValue?.Invoke(); } // here is error 
     set { SetValue?.Invoke(value); } 
    } 

    public Func<T> GetValue { get; set; } 
    public Action<T> SetValue { get; set; } 
} 

E 'possibile utilizzare questo codice al posto

get 
{ 
    if (GetValue != null) 
     return GetValue(); 
    return default(T); 
} 

ma mi chiedo come risolvere il problema quel bel one-liner C# 6.0.

Answer 1

Dal momento che non tutto può essere null, bisogna restringere T essere qualcosa annullabile (aka un object). Le strutture non possono essere nulle e nemmeno le enumerazioni.

Aggiunta di un where su class vuol risolvere il problema:

public abstract class Feature<T> where T : class 

Allora, perché non è solo di lavoro?

Invoke() rese T. Se GetValue è null, l'operatore ? imposta il valore di ritorno di tipo T su null, che non è possibile. Se T è int ad esempio, non può renderlo nullable (int?) poiché il tipo effettivo richiesto (T = int) non lo è.

Se si modifica nel proprio codice, il problema verrà visualizzato in modo chiaro. Il risultato finale di ciò che si chiede è questo:

get 
{ 
    int? x = GetValue?.Invoke(); 
    return x.GetValueOrDefault(0); 
} 

questo non è qualcosa l'operatore null-propagazione farà per voi. Se si ripristina l'uso di default(T), esso sa esattamente cosa fare ed evita la propagazione nulla "problematica".

Answer 2

Per quanto ne so l'operatore ?. è codificato per funzionare con null, cioè, funziona per i tipi di riferimento o tipi di valore nullable, ma non normali tipi di valore. È probabile che l'operatore restituisca null se l'espressione era null anziché default(T).

Potrebbe essere possibile risolvere il problema limitando T a class qui.

Answer 3

T deve essere un tipo di riferimento o un tipo nullable

public abstract class Feature<T> where T : class 
{ 
    // ... 
}