Types valeur Nullable (Visual Basic)

Article
06/23/2023

Parfois, vous travaillez avec un type valeur qui n’a pas de valeur définie dans certaines circonstances. Par exemple, un champ d’une base de données peut devoir faire la distinction entre avoir une valeur affectée qui est significative et ne pas avoir de valeur affectée. Les types de valeurs peuvent être étendus pour prendre leurs valeurs normales ou une valeur null. Une telle extension est appelée type nullable.

Chaque type de valeur nullable est construit à partir de la structure générique Nullable<T> . Envisagez une base de données qui effectue le suivi des activités liées au travail. L’exemple suivant construit un type nullable Boolean et déclare une variable de ce type. Vous pouvez écrire la déclaration de trois manières :

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

La variable ridesBusToWork peut contenir une valeur de True, une valeur de False, ou aucune valeur du tout. Sa valeur par défaut initiale n’est pas du tout une valeur, ce qui dans ce cas peut signifier que les informations n’ont pas encore été obtenues pour cette personne. En revanche, False pourrait signifier que l’information a été obtenue et que la personne ne prend pas l’autobus pour travailler.

Vous pouvez déclarer des variables et des propriétés avec des types de valeurs nullables, et vous pouvez déclarer un tableau avec des éléments d’un type valeur nullable. Vous pouvez déclarer des procédures avec des types de valeurs nullables en tant que paramètres, et vous pouvez retourner un type valeur nullable à partir d’une procédure Function.

Vous ne pouvez pas construire un type nullable sur un type de référence tel qu’un tableau, un Stringou une classe. Le type sous-jacent doit être un type valeur. Pour plus d'informations, consultez Value Types and Reference Types.

Utilisation d’une variable de type Nullable

Les membres les plus importants d’un type valeur nullable sont ses propriétés HasValue et Value. Pour une variable de type valeur nullable, HasValue vous indique si la variable contient une valeur définie. Si HasValue est True, vous pouvez lire la valeur à partir de Value. Notez que et HasValue et Value sont des propriétés ReadOnly.

Valeurs par défaut

Lorsque vous déclarez une variable avec un type de valeur nullable, sa propriété HasValue a la valeur par défaut False. Cela signifie que par défaut, la variable n’a aucune valeur définie, au lieu de la valeur par défaut de son type de valeur sous-jacent. Dans l’exemple suivant, la variable numberOfChildren n’a initialement aucune valeur définie, même si la valeur par défaut du type Integer est 0.

Dim numberOfChildren? As Integer

Une valeur null est utile pour indiquer une valeur non définie ou inconnue. Si numberOfChildren avait été déclaré en tant que Integer, aucune valeur ne pourrait indiquer que les informations ne sont pas actuellement disponibles.

Stockage de valeurs

Vous stockez une valeur dans une variable ou une propriété d’un type valeur nullable de la manière classique. L’exemple suivant affecte une valeur à la variable numberOfChildren déclarée dans l’exemple précédent.

numberOfChildren = 2

Si une variable ou une propriété d’un type valeur nullable contient une valeur définie, vous pouvez l’amener à revenir à son état initial de ne pas avoir de valeur affectée. Pour ce faire, définissez la variable ou la propriété sur Nothing, comme le montre l’exemple suivant.

numberOfChildren = Nothing

Notes

Bien que vous puissiez affecter Nothing à une variable d’un type de valeur nullable, vous ne pouvez pas la tester pour Nothing à l’aide du signe égal. La comparaison qui utilise le signe égal, someVar = Nothing, prend toujours la valeur Nothing. Vous pouvez tester la propriété de HasValue la variable pour False, ou tester à l’aide de l’opérateur Is ou IsNot.

Récupérer les valeurs

Pour récupérer la valeur d’une variable d’un type valeur nullable, vous devez d’abord tester sa propriété HasValue pour vérifier qu’elle a une valeur. Si vous essayez de lire la valeur quand HasValue est False, Visual Basic lève une InvalidOperationException exception. L’exemple suivant montre la méthode recommandée pour lire la variable numberOfChildren des exemples précédents.

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

Comparaison de types nullable

Lorsque des variables nullables Boolean sont utilisées dans des expressions booléennes, le résultat peut être True, Falseou Nothing. Voici le tableau de vérité pour And et Or. Étant donné que b1 et b2 ont maintenant trois valeurs possibles, il existe neuf combinaisons à évaluer.

b1	b2	b1 et b2	b1 ou 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`

Lorsque la valeur d’une variable ou d’une expression booléenne est Nothing, elle n’est ni true ni false. Considérez l'exemple suivant.

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

Dans cet exemple, b1 And b2 la valeur est Nothing. Par conséquent, la clause Else est exécutée dans chaque instruction If et la sortie est la suivante :

Expression is not true

Expression is not false

Notes

AndAlso et OrElse, qui utilisent l’évaluation de court-circuit, doivent évaluer leurs deuxièmes opérandes lorsque le premier évalue à Nothing.

Propagation

Si l’un ou les deux opérandes d’une opération arithmétique, de comparaison, de décalage ou de type est un type de valeur nullable, le résultat de l’opération est également un type valeur nullable. Si les deux opérandes ont des valeurs qui ne sont pas Nothing, l’opération est effectuée sur les valeurs sous-jacentes des opérandes, comme si ni l’un ni l’autre n’était un type de valeur nullable. Dans l’exemple suivant, les variables compare1 et sum1 sont implicitement typées. Si vous placez le pointeur de la souris sur ces variables, vous verrez que le compilateur déduit les types de valeurs nullables pour les deux.

' 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 l’un ou les deux opérandes ont la valeur Nothing, le résultat est 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>")}")

Utilisation de types nullables avec des données

Une base de données est l’un des emplacements les plus importants pour utiliser des types de valeurs nullables. Tous les objets de base de données ne prennent pas actuellement en charge les types de valeurs nullables, mais les adaptateurs de table générés par le concepteur le font. Voir Prise en charge de TableAdapter pour les types Nullable.

Partager via