La prossima versione del .NET Framework 2.0, nome in codice Whidbey , introduce una nuova feature molto utile: i Nullable Types . Grazie a questi sarà possibile assegnare null anche ai tipi valore (boolean, int, string, ecc. ecc.). Per fare un esempio, pensiamo ad una classe definita nel nostro progetto che rappresenta una tabella del database. Questa contiene una proprietà di tipo int che, rappresentando una relazione esterna con un'altra tabella, può assumere valore null. Con la versione attuale del .NET Framework si è costretti ad usare dei valori fittizi, ad esempio -1, per poi convertirli al momento dell'aggiornamento sul DB. Grazie ai NullableTypes ciò non sarà più necessario. Il loro campo di applicazione è maggiormente il colloquio con gli RDBMS, visto che molti comportamenti di questo tipo sono analoghi a quelli di ogni RDBMS. Ad esempio la somma di 2 nullable types di cui uno è null, non produce errrore, bensì null.

Nullable Types nel .NET Framework 2.0

L'implementazione dei Nullable Types nel .NET Framework 2.0 avviene tramite una struct che agisce da wrapper per un tipo definito tramite Generics . La struct pubblica 2 proprietà:

• Value : contiene il valore;
• HasValue : indica se è stato assegnato un valore null o meno.

Quando si assegna un valore al nullable type, si distinguono 2 casi:

• Il valore assegnato è null : la proprietà Value viene impostata al valore di default del tipo tramite la parola chiave default , altra nuova feature della 2.0. HasValue viene impostata a false per identificare che è stato assegnato il valore null;
• Il valore assegnato non è null: la proprietà Value viene impostata con il valore di input e HasValue a true.

Quando, viceversa, si vuole estrarre il valore della proprietà Value , se il valore di HasValue è false, viene generata un'eccezione simulando il valore null , altrimenti viene restituito correttamente il valore.

Un'altra novità, introdotta dai nullable types, è la sintassi. Per creare la struttura con un tipo generico int, la sintassi è la seguente.

Nullable<int> MyVar = new Nullable<int>(125);

Questa riga è comune per istanziare un oggetto o una struct, ma non un tipo per valore.

Ecco qui la nuova sintassi creata per rendere la creazione di un nullable types simile a quella di un normale tipo per valore.

int? MyVar = 1;

Nullable Types nel .NET Framework 1.x

Visto che Generics e default sono feature presenti solo in Whidbey, emulare il tutto nella versione attuale non è una cosa immediata, poiché dobbiamo definire una struttura per ogni tipo di cui abbiamo bisogno. In questo articolo vedremo come realizzare una struttura che faccia da wrapper per il tipo Int32, ma ovviamente il discorso può essere esteso facilmente a tutte le altre strutture.

Definizione della struttura

  public struct Int32NT : IComparable{
   public Int32NT (int  value){
     _value = value;
     _hasValue = true;
   }
   public static readonly Int32NT Null;
   
   private int _value;
   private bool _hasValue;

   public bool  HasValue{
     get { return _hasValue;  }
   }

   public int Value{
     get{ 
      if (_hasValue) 
        return _value;
      else
        throw new System.ArgumentNullException("_value"); 
     }
   }

   public int CompareTo(object value)  {
     if (value == null)
      return 1;

     if (!(value is Int32NT))
      throw new System.ArgumentException("Il parametro \"value\" deve essere di tipo Int32NT");
      Int32NT nt = (Int32NT)value;
      if (!nt._hasValue && !this._hasValue) return 0;
      if (!nt._hasValue) return 1;
      if (!nt._hasValue) return -1;
     
      return _value.CompareTo(nt.Value);
     }
   }
  }

Per prima cosa notiamo che la struttura implementa l'interfaccia IComparable per i confronti. Poi viene definita una variabile statica pubblica denominata Null che simula il valore null del framework. Infine ci sono le due proprietà che emulano quelle presenti nella struct Nullable di Whidbey: Value e HasValue . Questa è la base della struttura, necessaria per contenere il valore ed emulare il null. Se vogliamo implementare wrapper per altri tipi, questa è la parte che tutti devono obbligatoriamente implementare.

Il prossimo passo è creare alcuni metodi che permettano alla struttura di comportarsi "quasi" come un tipo Int32.