Nullable types

Een variabele die geen waarde heeft is NULL. NULL betekent letterlijk 'niets'. Misschien werden er tot hiertoe al variabelen gebruikt die niet geïnitialiseerd werden, al of niet met opzet. Variabelen moeten al een waarde hebben voordat er een nieuwe waarde aan toegekend kan worden, zo niet krijgt men een NullReferenceException.

NULL is vooral van toepassing bij eigen objecten en strings. Getallen daarentegen, bvb. een integer, heeft altijd een (standaard) waarde. Bij een integer is de standaarwaarde 0 (nul). Deze mag niet verward worden met NULL, alhoewel sommige niet-statische programmeertalen er geen onderscheid in maken. 0 is een getal en NULL is niets.

Dat kan dus problemen opleveren als er ooit een integer variabele nodig is die onbepaald/NULL is omdat null niet aan een integer kan toegewezen worden. Tenzij die integer gedefinieerd is als nullable. Dit is een speciale constructie voor in gevallen als dit. Een nullable variabele wordt gedefinieerd door er een vraagteken er achter te zetten. Volgend voorbeeld toont het verschil:

int notNullable = null; // Will cause an error from the compiler

int? nullable = null; // Just fine - it's nullable!

Dit geldt voor alle zogenaamde value types zoals integers, floats, bools en structs. Strings en objecten daarentegen zijn reference types en kunnen niet als nullable gedeclareerd worden omdat zij per definitie nullable zijn.

Een nullable controleren op null

Nu dat een variabele gedeclareerd mag worden als null, moet dat ook gecontroleerd worden. Dit kan op twee manieren: gewoon vergelijken met het sleutelwoord 'null' zoals bij andere types of gebruik maken van de HasValue eigenschap die een nullable object erft van de System.Nullable struct. Hier is een voorbeeld:

int? nullable = null;  
if (nullable == null)  
    Console.WriteLine("It's a null!");  
if (!nullable.HasValue)  
    Console.WriteLine("It's a null!");

Het resultaat is hetzelfde. Gebruik de methode die het meest leesbaar en begrijpbaar is. Nu dat een variabele null kan zijn, moet die altijd gecontroleerd worden voordat ze gebruikt wordt, anders kan er een Exception volgen.

Gebruik van de waarde van een nullable

Een nullable object erft van System.Nullable ook de eigenschap Value. Dit kan gebruikt worden om de actuele waarde waarde van een nullable object te kennen. Voor eenvoudige vergelijkingen, zoals de == en de != operatoren, laat C# echter toe de Value eigenschap weg te laten en gewoon de nullable objecten te vergelijken. Met andere woorden beide voorbeelden doen hetzelfde:

int? nullable = 42;

if (nullable.Value == 42)  
    Console.WriteLine("It's 42!");  

if (nullable == 42)  
    Console.WriteLine("It's 42!");

Nullable objecten komen altijd van een basis gegevenstype zoals van een integer in voorgaande voorbeelden. Terwijl deze gegevenstypes een standaard waarde hebben, is de standaard waarde van een nullable altijd null. Daarom moet altijd op null gecontroleerd worden voordat de variabele kan gebruikt worden. Een nullable erft echter een leuke hulpmethode: GetValueOrDefault(). Deze geeft de waarde van een nullable object, tenzij deze null is, dan wordt de standaard waarde van het onderliggende type gegeven. Dus voor een nullable integer wordt 0 weergegeven, voor een nullable boolean is dat false en zo verder. Dit laat controle en opzoeking toe van een waarde in één enkele instructie:

if ((nullable.HasValue) && (nullable.Value == 42))
    Console.WriteLine("It's 42!");

if(nullable.GetValueOrDefault() == 42)
    Console.WriteLine("It's 42!");

Het is duidelijk dat dit laatste voorbeeld korter en beter leesbaar is terwijl hetzelfde resultaat bereikt wordt.

Samenvatting

In C# hebben value types zoals integers en booleans altijd een standaard waarde. Om dit te omzeilen, bijvoorbeeld om een onderscheid te maken tussen 0 en null, of als men wil weten of de gebruiker actief "false" gekozen heeft, of als de variabele gewoon de standaard waarde false heeft, maakt men de variabele nullable door er een ? (vraagteken) achter te zetten.