# Nullable Value Types (Visual Basic)

Sometimes you work with a value type that does not have a defined value in certain circumstances. For example, a field in a database might have to distinguish between having an assigned value that is meaningful and not having an assigned value. Value types can be extended to take either their normal values or a null value. Such an extension is called a nullable type.

Each nullable type is constructed from the generic Nullable<T> structure. Consider a database that tracks work-related activities. The following example constructs a nullable Boolean type and declares a variable of that type. You can write the declaration in three ways:

Dim ridesBusToWork1? As Boolean
Dim ridesBusToWork2 As Boolean?
Dim ridesBusToWork3 As Nullable(Of Boolean)


The variable ridesBusToWork can hold a value of True, a value of False, or no value at all. Its initial default value is no value at all, which in this case could mean that the information has not yet been obtained for this person. In contrast, False could mean that the information has been obtained and the person does not ride the bus to work.

You can declare variables and properties with nullable types, and you can declare an array with elements of a nullable type. You can declare procedures with nullable types as parameters, and you can return a nullable type from a Function procedure.

You cannot construct a nullable type on a reference type such as an array, a String, or a class. The underlying type must be a value type. For more information, see Value Types and Reference Types.

## Using a Nullable Type Variable

The most important members of a nullable type are its HasValue and Value properties. For a variable of a nullable type, HasValue tells you whether the variable contains a defined value. If HasValue is True, you can read the value from Value. Note that both HasValue and Value are ReadOnly properties.

### Default Values

When you declare a variable with a nullable type, its HasValue property has a default value of False. This means that by default the variable has no defined value, instead of the default value of its underlying value type. In the following example, the variable numberOfChildren initially has no defined value, even though the default value of the Integer type is 0.

Dim numberOfChildren? As Integer


A null value is useful to indicate an undefined or unknown value. If numberOfChildren had been declared as Integer, there would be no value that could indicate that the information is not currently available.

### Storing Values

You store a value in a variable or property of a nullable type in the typical way. The following example assigns a value to the variable numberOfChildren declared in the previous example.

numberOfChildren = 2


If a variable or property of a nullable type contains a defined value, you can cause it to revert to its initial state of not having a value assigned. You do this by setting the variable or property to Nothing, as the following example shows.

numberOfChildren = Nothing


Note

Although you can assign Nothing to a variable of a nullable type, you cannot test it for Nothing by using the equal sign. Comparison that uses the equal sign, someVar = Nothing, always evaluates to Nothing. You can test the variable's HasValue property for False, or test by using the Is or IsNot operator.

### Retrieving Values

To retrieve the value of a variable of a nullable type, you should first test its HasValue property to confirm that it has a value. If you try to read the value when HasValue is False, Visual Basic throws an InvalidOperationException exception. The following example shows the recommended way to read the variable numberOfChildren of the previous examples.

If numberOfChildren.HasValue Then
MsgBox("There are " & CStr(numberOfChildren) & " children.")
Else
MsgBox("It is not known how many children there are.")
End If


## Comparing Nullable Types

When nullable Boolean variables are used in Boolean expressions, the result can be True, False, or Nothing. The following is the truth table for And and Or. Because b1 and b2 now have three possible values, there are nine combinations to evaluate.

b1 b2 b1 And b2 b1 Or b2
Nothing Nothing Nothing Nothing
Nothing True Nothing True
Nothing False False Nothing
True Nothing Nothing True
True True True True
True False False True
False Nothing False Nothing
False True False True
False False False False

When the value of a Boolean variable or expression is Nothing, it is neither true nor false. Consider the following example.

Dim b1? As Boolean
Dim b2? As Boolean
b1 = True
b2 = Nothing

' The following If statement displays "Expression is not true".
If (b1 And b2) Then
Console.WriteLine("Expression is true")
Else
Console.WriteLine("Expression is not true")
End If

' The following If statement displays "Expression is not false".
If Not (b1 And b2) Then
Console.WriteLine("Expression is false")
Else
Console.WriteLine("Expression is not false")
End If


In this example, b1 And b2 evaluates to Nothing. As a result, the Else clause is executed in each If statement, and the output is as follows:

Expression is not true

Expression is not false

Note

AndAlso and OrElse, which use short-circuit evaluation, must evaluate their second operands when the first evaluates to Nothing.

## Propagation

If one or both of the operands of an arithmetic, comparison, shift, or type operation is nullable, the result of the operation is also nullable. If both operands have values that are not Nothing, the operation is performed on the underlying values of the operands, as if neither were a nullable type. In the following example, variables compare1 and sum1 are implicitly typed. If you rest the mouse pointer over them, you will see that the compiler infers nullable types for both of them.

' Variable n is a nullable type, but both m and n have proper values.
Dim m As Integer = 3
Dim n? As Integer = 2

' The comparison evaluated is 3 > 2, but compare1 is inferred to be of
' type Boolean?.
Dim compare1 = m > n
' The values summed are 3 and 2, but sum1 is inferred to be of type Integer?.
Dim sum1 = m + n

' The following line displays: 3 * 2 * 5 * True
Console.WriteLine($"{m} * {n} * {sum1} * {compare1}")  If one or both operands have a value of Nothing, the result will be Nothing. ' Change the value of n to Nothing. n = Nothing Dim compare2 = m > n Dim sum2 = m + n ' Because the values of n, compare2, and sum2 are all Nothing, the ' following line displays: 3 * <null> * <null> * <null> Console.WriteLine($"{m} * {If(n, "<null>")} * {If(sum2, "<null>")} * {If(compare2, "<null>")}")


## Using Nullable Types with Data

A database is one of the most important places to use nullable types. Not all database objects currently support nullable types, but the designer-generated table adapters do. See TableAdapter support for nullable types.