? (nullable) operatore in C#

Question

Cosa viene modificato applicando Operatore nullable su tipo di tipo di dati valore che ora può memorizzare null.

Answer 1

Come altri hanno già detto, "?" è solo una scorciatoia per cambiarlo in Nullable<T>. Questo è solo un altro tipo di valore con un flag booleano per dire se c'è davvero un valore utile o se è il valore nullo per il tipo. In altre parole, Nullable<T> sembra un po 'come questo:

public struct Nullable<T> 
{ 
    private readonly bool hasValue; 
    public bool HasValue { get { return hasValue; } } 

    private readonly T value; 
    public T value 
    { 
     get 
     { 
      if (!hasValue) 
      { 
       throw new InvalidOperationException(); 
      } 
      return value; 
     } 
    } 

    public Nullable(T value) 
    { 
     this.value = value; 
     this.hasValue = true; 
    } 

    // Calling new Nullable<int>() or whatever will use the 
    // implicit initialization which leaves value as default(T) 
    // and hasValue as false. 
} 

Ovviamente nel codice vero e proprio ci sono più metodi (come GetValueOrDefault()) e operatori di conversione, ecc Il compilatore C# aggiunge sollevato operatori che di fatto delega all'originale operatori per T.

A rischio di sembrare un record interrotto, questo è ancora un tipo di valore. Si non si coinvolgono la boxe ... e quando si scrive:

int? x = null; 

che non è un nulla di riferimento - è il valore nullo di Nullable<int>, vale a dire quello in cui è hasValuefalse.

Quando un tipo nullable è inscatolato, il CLR ha una caratteristica per cui il valore sia viene inscatolato ad un riferimento nullo, o un semplice scatola T. Quindi, se si dispone di codice come questo:

int? x = 5; 
int y = 5; 

object o1 = x; 
object o2 = y; 

I valori in scatola a cui si riferisce o1 e o2 non sono distinguibili. Non si può dire che uno è il risultato del pugilato di un tipo nullable.

Answer 2

La sintassi ? è zucchero sintattico nella struttura Nullable<T>.

In pratica, quando si scrive int? myNullableInt, il compilatore lo modifica in Nullable<int> myNullableInt.

Da MSDN (scorrere fino a "Tipi Nullable Panoramica"):

La sintassi T? è una scorciatoia per Nullable, dove T è un tipo di valore. Le due forme sono intercambiabili.

Answer 3

In termini di base, un tipo nullable è una versione in scatola del tipo normale che ha un campo booleano aggiuntivo chiamato hasValue su di esso. Quando questo campo è impostato su false, l'istanza è nullo.

Partenza questa risposta per un po 'più in dettaglio sulla realizzazione CLR, e perché avrebbero potuto scelto: Boxing/Unboxing Nullable Types - Why this implementation?

Answer 4

Il tipo di cambiamenti da quello che ha usato per essere a un tipo Nullable.

Se tu avessi un int, e ha deciso di renderlo un int ?:

int myInt; 

E si rendono:

int? myInt; 

è ora:

Nullable<int> myInt; 

In la realtà.

Answer 5

Non viene modificato nulla sul tipo di valore stesso, è semplicemente racchiuso in una struttura System.Nullable<T>. http://msdn.microsoft.com/en-us/library/b3h38hb0.aspx