Tipos que admiten valores null (Visual Basic)

A veces trabaja con un tipo de valor que no tiene un valor definido en ciertas circunstancias.Por ejemplo, puede que un campo de una base de datos tenga que distinguir entre tener un valor asignado que es significativo y no tener un valor asignado.Los tipos de valor se pueden extender para tomar sus valores normales o un valor nulo.Este tipo de extensión se denomina un tipo que acepta valores NULL.

Los tipos que aceptan valores NULL se construyen a partir de la estructura genérica Nullable<T>.Considere una base de datos que realiza el seguimiento de las actividades relacionadas con el trabajo.El ejemplo siguiente construye un tipo Boolean que acepta valores NULL y declara una variable de ese tipo.Puede escribir la declaración de tres maneras:

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

La variable ridesBusToWork pueden contener un valor True, un valor False o ninguno de ellos.Su valor predeterminado inicial es ningún valor, lo que en este caso podría significar que todavía no se ha obtenido la información correspondiente a esta persona.False, por su parte, podría significar que se ha obtenido la información y la persona no utiliza el autobús para ir al trabajo.

Puede declarar variables y propiedades con tipos que aceptan valores NULL y puede declarar una matriz con elementos de un tipo que acepta valores NULL.Puede declarar procedimientos con tipos que aceptan valores NULL como parámetros y puede devolver un tipo que acepta valores NULL de un procedimiento Function.

No puede construir un tipo que acepta valores NULL en un tipo de referencia como una matriz, un objeto String o una clase.El tipo subyacente debe ser un tipo de valor.Para obtener más información, vea Tipos de valor y tipos de referencia.

Utilizar una variable de tipo que acepta valores NULL

Los miembros más importantes de un tipo que acepta valores NULL son sus propiedades HasValue y Value.En una variable de un tipo que acepta valores NULL, HasValue indica si la variable contiene un valor definido.Si HasValue tiene el valor True, puede leer el valor de Value.Observe que HasValue y Value son propiedades de tipo ReadOnly.

Valores predeterminados

Cuando declara una variable con un tipo que acepta valores NULL, su propiedad HasValue tiene un valor predeterminado de False.Esto significa que la variable no tiene ningún valor definido de forma predeterminada, en lugar del valor predeterminado de su tipo de valor subyacente.En el ejemplo siguiente, la variable numberOfChildren no tiene inicialmente ningún valor definido, aunque el valor predeterminado del tipo Integer es 0.

Dim numberOfChildren? As Integer

Un valor nulo es útil para indicar un valor indefinido o desconocido.Si numberOfChildren se hubiese declarado como Integer, no habría ningún valor que indicase que la información no está disponible actualmente.

Almacenar valores

El almacenamiento de un valor en una variable o una propiedad que acepta valores NULL se realiza de la manera habitual.En el ejemplo siguiente se asigna un valor a la variable numberOfChildren declarada en el ejemplo anterior.

numberOfChildren = 2

Si una variable o una propiedad de un tipo que acepta valores NULL contiene un valor definido, puede determinar que vuelva a su estado inicial, es decir, sin ningún valor asignado.Para ello, establece la variable o la propiedad como Nothing, según se muestra en el ejemplo siguiente.

numberOfChildren = Nothing

[!NOTA]

Aunque puede asignar Nothing a una variable que acepta valores Null, no puede probarla con Nothing usando el signo igual.La comparación que usa el signo igual, someVar = Nothing, siempre se evalúa como Nothing.Puede probar la propiedad HasValue de la variable con False o probar mediante el operador Is o IsNot.

Recuperar valores

Para recuperar el valor de una variable de un tipo que acepta valores NULL, debe probar previamente su propiedad HasValue para confirmar que incluye un valor.Si intenta leer el valor cuando HasValue es False, Visual Basic produce una excepción InvalidOperationException.En el ejemplo siguiente se muestra la manera recomendada de leer la variable numberOfChildren de los ejemplos anteriores.

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

Comparar tipos que aceptan valores NULL

Cuando se usan en expresiones booleanas variables Boolean que aceptan valores NULL, el resultado puede ser True, False o Nothing.A continuación, se muestra la tabla de valores de verdad para And y Or.Dado que b1 y b2 tienen ahora tres posibles valores, hay nueve combinaciones que se pueden evaluar.

b1	b2	b1 Y b2	b1 O 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

Cuando el valor de una variable o expresión booleana es Nothing, no es true ni false.Considere el ejemplo siguiente.

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

En este ejemplo, b1 And b2 se evalúa como Nothing.Como resultado, la cláusula Else se ejecuta en cada instrucción If y el resultado es como sigue:

Expression is not true

Expression is not false

[!NOTA]

AndAlso y OrElse, que usan la evaluación de cortocircuito, deben evaluar sus segundos operandos cuando el primero se evalúa como Nothing.

Propagación

Si uno de los operandos o ambos operandos de una operación aritmética, de comparación, de desplazamiento o con tipos aceptan valores NULL, el resultado de la operación también acepta valores NULL.Si ambos operandos tienen valores que no son Nothing, la operación se realiza con los valores subyacentes de los operandos, como si ninguno fuera un tipo que acepta valores NULL.En el ejemplo siguiente, las variables compare1 y sum1 son variables de tipo implícito.Si coloca el puntero del mouse sobre ellas, observará que el compilador deduce los tipos que aceptan valores NULL para ambas variables.

' 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)

Si uno o ambos operandos tienen el valor Nothing, el resultado será 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 * * *
Console.WriteLine(m & " * " & n & " * " & sum2 & " * " & compare2)

Utilizar tipos que aceptan valores NULL con datos

Una base de datos es uno de los lugares más importantes para utilizar tipos que aceptan valores NULL.No todos los objetos de base de datos son actualmente compatibles con los tipos que aceptan valores NULL, pero sí lo son los adaptadores de tablas generadas por el diseñador.Vea la sección sobre compatibilidad de TableAdapter con tipos que aceptan valores NULL en Información general sobre TableAdapter.

Vea también

Tareas

Solucionar problemas de tipos de datos (Visual Basic)

Referencia

Utilizar tipos que aceptan valores NULL (Guía de programación de C#)

InvalidOperationException

If (Operador) (Visual Basic)

Is (Operador, Visual Basic)

IsNot (Operador) (Visual Basic)

HasValue

Conceptos

Tipos de datos en Visual Basic

Tipos de valor y tipos de referencia

Información general sobre TableAdapter

Inferencia de tipo de variable local (Visual Basic)