In C # 8.0 possiamo avere tipi di riferimento nulli. I documenti affermano che esistono 4 tipi di nullability. I primi 3 sono abbastanza chiari ma non riesco a capire il punto di "sconosciuto". I documenti dicono che è usato con generici ma quando provo a chiamare un metodo su una variabile non vincolata di tipo T in generici avverte semplicemente come se il tipo fosse nullable. Non riesco a vedere la differenza tra sconosciuto e nullable. Perché esiste l'ignoto? Come si manifesta?
Risposte:
Prendi il seguente metodo generico:
public static T Get<T>(T value)
{
return value;
}Se lo chiamiamo così Get<string>(s), il ritorno è non annullabile e, se lo facciamo Get<string?>(s), è nullable.
Tuttavia, se lo chiami con un argomento generico come Get<T>(x)e Tnon viene risolto, ad esempio è un argomento generico per la tua classe generica come di seguito ...
class MyClass<T>
{
void Method(T x)
{
var result = Get<T>(x);
// is result nullable or non-nullable? It depends on T
}
}Qui il compilatore non sa se alla fine verrà chiamato con un tipo nullable o non nullable.
Esiste un nuovo vincolo di tipo che possiamo usare per segnalare che Tnon può essere nullo:
public static T Get<T>(T value) where T: notnull
{
return value;
}Tuttavia, dove Tnon è vincolato e è ancora aperto, la nullabilità è sconosciuta.
Se questi incogniti sono stati considerati nullable, è possibile scrivere il seguente codice:
class MyClass<T>
{
void Method(T x)
{
var result = Get<T>(x);
// reassign result to null, cause we we could if unknown was treated as nullable
result = null;
}
}Nel caso in cui Tnon fosse nullable, avremmo dovuto ricevere un avviso. Quindi, con tipi di nullability sconosciuti, desideriamo avvisi durante la dereferenziazione, ma anche avvisi per l'assegnazione potenziale null.