C# in Depth

System.Nullable and System.Nullable115PATTERN 2: A REFERENCE TYPE WRAPPERThe second solution can take two forms. The simpler one is to just use object as thevariable type, boxing and unboxing values as necessary. The more complex (andrather more appealing) form is to have a reference type for each value type you needin a nullable form, containing a single instance variable of that value type, and withimplicit conversion operators to and from the value type. With generics, you could dothis in one generic type—but if you’re using C# 2 anyway, you might as well use thenullable types described in this chapter instead. If you’re stuck in C# 1, you have tocreate extra source code for each type you wish to wrap. This isn’t hard to put in theform of a template for automatic code generation, but it’s still a burden that is bestavoided if possible.Both of these forms have the problem that while they allow you to use nulldirectly, they do require objects to be created on the heap, which can lead to garbagecollection pressure if you need to use this approach very frequently, and adds memoryuse due to the overheads associated with objects. For the more complex solution, youcould make the reference type mutable, which may reduce the number of instancesyou need to create but could also make for some very unintuitive code.PATTERN 3: AN EXTRA BOOLEAN FLAGThe final pattern revolves around having a normal value type value available, andanother value—a Boolean flag—indicating whether the value is “real” or whether itshould be disregarded. Again, there are two ways of implementing this solution.Either you could maintain two separate variables in the code that uses the value, oryou could encapsulate the “value plus flag” into another value type.This latter solution is quite similar to the more complicated reference type ideadescribed earlier, except that you avoid the garbage-collection issue by using a valuetype, and indicate nullity within the encapsulated value rather than by virtue of a nullreference. The downside of having to create a new one of these types for every valuetype you wish to handle is the same, however. Also, if the value is ever boxed for somereason, it will be boxed in the normal way whether it’s considered to be null or not.The last pattern (in the more encapsulated form) is effectively how nullable typeswork in C# 2. We’ll see that when the new features of the framework, CLR, and languageare all combined, the solution is significantly neater than anything that was possible inC# 1. Our next section deals with just the support provided by the framework and theCLR: if C# 2 only supported generics, the whole of section 4.2 would still be relevant andthe feature would still work and be useful. However, C# 2 provides extra syntactic sugarto make it even better—that’s the subject of section 4.3.4.2 System.Nullable and System.NullableThe core structure at the heart of nullable types is System.Nullable. In addition,the System.Nullable static class provides utility methods that occasionally make nullabletypes easier to work with. (From now on I’ll leave out the namespace, to make lifesimpler.) We’ll look at both of these types in turn, and for this section I’ll avoid any extrafeatures provided by the language, so you’ll be able to understand what’s going on inthe IL code when we do look at the C# 2 syntactic sugar.Licensed to Rhona Hadida