Auf NULL festlegbare Werttypen (Visual Basic)

2025-06-20

Manchmal arbeiten Sie mit einem Werttyp, der unter bestimmten Umständen keinen definierten Wert aufweist. Ein Feld in einer Datenbank muss z. B. zwischen einem zugewiesenen Wert unterscheiden, der aussagekräftig ist und keinen zugewiesenen Wert aufweist. Werttypen können erweitert werden, um entweder ihre normalen Werte oder einen Nullwert zu verwenden. Eine solche Erweiterung wird als nullabler Typ bezeichnet.

Jeder nullable Werttyp wird aus der generischen Nullable<T> Struktur erstellt. Betrachten Sie eine Datenbank, die arbeitsbezogene Aktivitäten nachverfolgt. Im folgenden Beispiel wird ein nullabler Boolean Typ erstellt und eine Variable dieses Typs deklariert. Sie können die Deklaration auf drei Arten schreiben:

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

Die Variable ridesBusToWork kann einen Wert von True, einen Wert von Falseoder gar keinen Wert enthalten. Der anfängliche Standardwert ist überhaupt kein Wert, was in diesem Fall bedeuten könnte, dass die Informationen für diese Person noch nicht abgerufen wurden. Im Gegensatz dazu könnte dies bedeuten, False dass die Informationen erhalten wurden und die Person nicht mit dem Bus fährt, um zu arbeiten.

Sie können Variablen und Eigenschaften mit Nullwerttypen deklarieren, und Sie können ein Array mit Elementen eines Nullwertetyps deklarieren. Sie können Prozeduren mit Nullwerttypen als Parameter deklarieren und einen Nullwertetyp aus einer Function Prozedur zurückgeben.

Sie können keinen nullfähigen Typ für einen Verweistyp erstellen, z. B. ein Array, eine Stringoder eine Klasse. Der zugrunde liegende Typ muss ein Werttyp sein. Weitere Informationen finden Sie unter Werttypen und Referenztypen.

Verwenden einer Nullable-Typvariablen

Die wichtigsten Elemente eines Nullwerttyps sind die zugehörigen HasValue und Value Eigenschaften. Bei einer Variablen eines nullable Werttyps gibt HasValue an, ob die Variable einen definierten Wert enthält. Wenn HasValueTrue ist, können Sie den Wert von Value lesen. Beachten Sie, dass sowohl HasValue als auch ValueReadOnly-Eigenschaften sind.

Standardwerte

Wenn Sie eine Variable mit einem Nullwerttyp deklarieren, hat die HasValue Eigenschaft einen Standardwert von False. Dies bedeutet, dass die Variable standardmäßig keinen definierten Wert anstelle des Standardwerts des zugrunde liegenden Werttyps aufweist. Im folgenden Beispiel weist die Variable numberOfChildren zunächst keinen definierten Wert auf, obwohl der Standardwert des Integer Typs 0 ist.

Dim numberOfChildren? As Integer

Ein Nullwert ist nützlich, um einen nicht definierten oder unbekannten Wert anzugeben. Wenn numberOfChildren als Integer deklariert worden wäre, gäbe es keinen Wert, der anzeigen könnte, dass die Informationen derzeit nicht verfügbar sind.

Speichern von Werten

Sie speichern einen Wert in einer Variablen oder Eigenschaft eines Nullwertetyps auf typische Weise. Im folgenden Beispiel wird der im vorherigen Beispiel deklarierten Variablen numberOfChildren ein Wert zugewiesen.

numberOfChildren = 2

Wenn eine Variable oder Eigenschaft eines nullablen Werttyps einen definierten Wert enthält, können Sie dazu führen, dass sie auf den Anfangszustand zurückgesetzt wird, dem kein Wert zugewiesen ist. Dazu legen Sie die Variable oder Eigenschaft wie im folgenden Beispiel dargestellt auf Nothingfest.

numberOfChildren = Nothing

Hinweis

Obwohl Sie Nothing einer Variablen eines Nullable-Werttyps zuweisen können, können Sie es nicht mittels des Gleichheitszeichens auf Nothing testen. Ein Vergleich, der das Gleichheitszeichen someVar = Nothing verwendet, ergibt immer Nothing. Sie können die HasValue-Eigenschaft der Variablen für False testen oder mithilfe des Is-Operators oder IsNot testen.

Abrufen von Werten

Um den Wert einer Variablen eines Nullwerttyps abzurufen, sollten Sie zuerst die HasValue Eigenschaft testen, um zu bestätigen, dass sie einen Wert aufweist. Wenn Sie versuchen, den Wert zu lesen, wenn HasValueFalse ist, wirft Visual Basic eine InvalidOperationException Ausnahme. Das folgende Beispiel zeigt die empfohlene Methode zum Lesen der Variablen numberOfChildren der vorherigen Beispiele.

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

Vergleich nullfähiger Typen

Wenn nullable Boolean Variablen in booleschen Ausdrücken verwendet werden, kann das Ergebnis sein True, oder FalseNothing. Es folgt die Wahrheitstabelle für And und Or. Da b1 und b2 jetzt drei mögliche Werte vorhanden sind, gibt es neun Kombinationen, die ausgewertet werden sollen.

b1	b2	b1 Und b2	b1 Oder 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`

Wenn der Wert einer booleschen Variablen oder eines Ausdrucks lautet Nothing, ist er weder true noch false. Betrachten Sie das folgende Beispiel.

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 diesem Beispiel wird b1 And b2 zu Nothing ausgewertet. Daher wird die Else Klausel in jeder If Anweisung ausgeführt, und die Ausgabe lautet wie folgt:

Expression is not true

Expression is not false

Hinweis

AndAlso und OrElse, die Kurzschlussauswertung verwenden, müssen ihre zweiten Operanden auswerten, wenn die erste zu Nothing ausgewertet wird.

Verbreitung

Wenn einer oder beide Operanden eines Arithmetik-, Vergleichs-, Schicht- oder Typvorgangs ein Nullwerttyp ist, ist das Ergebnis des Vorgangs auch ein Nullwerttyp. Wenn beide Operanden Werte haben, die nicht Nothing sind, wird die Operation für die zugrunde liegenden Werte der Operanden ausgeführt, als ob keiner ein Nullwerttyp wäre. Im folgenden Beispiel werden Variablen compare1 und sum1 implizit eingegeben. Wenn Sie mit dem Mauszeiger darauf zeigen, sehen Sie, dass der Compiler nullable Werttypen für beide ableiten kann.

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

Wenn ein oder beide Operanden einen Wert Nothinghaben, lautet Nothingdas Ergebnis .

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

Verwenden nullabler Typen mit Daten

Eine Datenbank ist einer der wichtigsten Bereiche, um nullbare Werttypen zu verwenden. Nicht alle Datenbankobjekte unterstützen derzeit Nullwertetypen, wohl aber die vom Designer generierten Tabellenadapter. Siehe TableAdapter-Unterstützung für nullwerte Typen.

Freigeben über