Typen null-waarden (C#-verwijzing)

Een dat null kan worden gebruikt, vertegenwoordigt alle waarden van het onderliggende T? en een extra null-waardeT. U kunt bijvoorbeeld een van de volgende drie waarden toewijzen aan een bool? variabele: true, falseof null. Een onderliggend waardetype T kan geen type null-waarde zelf zijn.

De C#-taalreferentiedocumenten de laatst uitgebrachte versie van de C#-taal. Het bevat ook de eerste documentatie voor functies in openbare previews voor de aanstaande taalrelease.

De documentatie identificeert alle functies die voor het eerst zijn geïntroduceerd in de laatste drie versies van de taal of in de huidige openbare previews.

Een null-waardetype is een exemplaar van de algemene System.Nullable<T> structuur. U kunt verwijzen naar een type null-waarde met een onderliggend type T in een van de volgende uitwisselbare formulieren: Nullable<T> of T?.

Gebruik doorgaans een type null-waarde wanneer u de niet-gedefinieerde waarde van een onderliggend waardetype moet weergeven. Een Booleaanse waarde of boolvariabele kan bijvoorbeeld alleen true een of false. In sommige toepassingen kan een variabele waarde echter niet gedefinieerd of ontbreken. Een databaseveld kan bijvoorbeeld een waarde bevatten of false, of het kan helemaal geen waarde bevattentrue, dat wil NULLgezegd. U kunt het bool? type in dat scenario gebruiken.

Declaratie en toewijzing

Omdat een waardetype impliciet wordt omgezet in het overeenkomstige type null-waarde, kunt u een waarde toewijzen aan een variabele van een type null-waarde zoals u dat doet voor het onderliggende waardetype. U kunt ook de null waarde toewijzen. Voorbeeld:

double? pi = 3.14;
char? letter = 'a';

int m2 = 10;
int? m = m2;

bool? flag = null;

// An array of a nullable value type:
int?[] arr = new int?[10];

De standaardwaarde van een type null-waarde vertegenwoordigt null. Het is een exemplaar waarvan Nullable<T>.HasValue de eigenschap retourneert false.

Onderzoek van een exemplaar van een type null-waarde

Als u een exemplaar van een type null-waarde wilt null controleren en een waarde van een onderliggend type wilt ophalen, gebruikt u de is operator met een typepatroon:

int? a = 42;
if (a is int valueOfA)
{
    Console.WriteLine($"a is {valueOfA}");
}
else
{
    Console.WriteLine("a does not have a value");
}
// Output:
// a is 42

U kunt altijd de volgende alleen-lezen eigenschappen gebruiken om een waarde van een variabele van het type null-waarde te controleren en op te halen:

• Nullable<T>.HasValue geeft aan of een exemplaar van een type null-waarde een waarde van het onderliggende type heeft.

• Nullable<T>.Value haalt de waarde van een onderliggend type op als HasValue dat het is true. Als HasValue dat het is false, gooit de Value eigenschap een InvalidOperationException.

In het volgende voorbeeld wordt de HasValue eigenschap gebruikt om te controleren of de variabele een waarde bevat voordat deze wordt weergegeven:

int? b = 10;
if (b.HasValue)
{
    Console.WriteLine($"b is {b.Value}");
}
else
{
    Console.WriteLine("b does not have a value");
}
// Output:
// b is 10

U kunt ook een variabele van een type null-waarde vergelijken met null in plaats van de HasValue eigenschap te gebruiken, zoals in het volgende voorbeeld wordt weergegeven:

int? c = 7;
if (c != null)
{
    Console.WriteLine($"c is {c.Value}");
}
else
{
    Console.WriteLine("c does not have a value");
}
// Output:
// c is 7

Conversie van een waardetype met null-waarde naar een onderliggend type

Als u een waarde van een type null-waarde wilt toewijzen aan een variabele voor een niet-null-waardetype, moet u mogelijk de waarde opgeven die moet worden toegewezen in plaats van null. Gebruik hiervoor de operator ??null-coalescing. U kunt de Nullable<T>.GetValueOrDefault(T) methode ook gebruiken voor hetzelfde doel:

int? a = 28;
int b = a ?? -1;
Console.WriteLine($"b is {b}");  // output: b is 28

int? c = null;
int d = c ?? -1;
Console.WriteLine($"d is {d}");  // output: d is -1

Als u de standaardwaarde van het onderliggende waardetype in plaats van nullwilt gebruiken, gebruikt u de Nullable<T>.GetValueOrDefault() methode.

U kunt ook expliciet een type null-waarde naar een niet-null-type casten, zoals in het volgende voorbeeld wordt weergegeven:

int? n = null;

//int m1 = n;    // Doesn't compile
int n2 = (int)n; // Compiles, but throws an exception if n is null

Als de waarde van een type null-waarde in runtime is null, genereert de expliciete cast een InvalidOperationException.

Een niet-null-waardetype T wordt impliciet omgezet in het bijbehorende type T?null-waarde.

Opgetilde operatoren

Een waardetype T? dat null kan worden gebruikt, ondersteunt de vooraf gedefinieerde unaire en binaire operatoren of eventuele overbelaste operators die door een waardetype T worden ondersteund. Deze operators, ook wel lifted operators genoemd, retourneren null als een of beide operanden zijn null. Anders gebruikt de operator de ingesloten waarden van de operanden om het resultaat te berekenen. Voorbeeld:

int? a = 10;
int? b = null;
int? c = 10;

a++;        // a is 11
a = a * c;  // a is 110
a = a + b;  // a is null

Voor de vergelijkingsoperatoren< , ><=en , als >=een of beide operanden zijn null, is falsehet resultaat . Anders worden de ingesloten waarden van operanden vergeleken. Neem niet aan dat omdat een bepaalde vergelijking (bijvoorbeeld ) retourneert false, de tegenovergestelde vergelijking (>) retourneert true. <= In het volgende voorbeeld ziet u dat 10 is

• niet groter dan of gelijk aan null
• niet kleiner dan null

int? a = 10;
Console.WriteLine($"{a} >= null is {a >= null}");
Console.WriteLine($"{a} < null is {a < null}");
Console.WriteLine($"{a} == null is {a == null}");
// Output:
// 10 >= null is False
// 10 < null is False
// 10 == null is False

int? b = null;
int? c = null;
Console.WriteLine($"null >= null is {b >= c}");
Console.WriteLine($"null == null is {b == c}");
// Output:
// null >= null is False
// null == null is True

Als beide operanden voor de gelijkheidsoperator== zijn null, is truehet resultaat . Als slechts één van de operanden is, is nullfalsehet resultaat . Anders worden de ingesloten waarden van operanden vergeleken.

Als beide operanden voor de ongelijkheidsoperator!= zijn null, is falsehet resultaat . Als slechts één van de operanden is, is nulltruehet resultaat . Anders worden de ingesloten waarden van operanden vergeleken.

Als er een door de gebruiker gedefinieerde conversie bestaat tussen twee waardetypen, kan dezelfde conversie ook worden gebruikt tussen de bijbehorende typen null-waarden.

Boksen en uitpakken

De volgende regels zijn van toepassing wanneer u een exemplaar van een type null-waarde T?opgeeft:

• Als HasValue het resultaat wordt falsegeretourneerd, retourneert de boksbewerking de null-verwijzing.
• Als HasValue het resultaat wordt geretourneerd, wordt met de boksbewerking truede bijbehorende waarde van het onderliggende waardetype T, niet het exemplaar van Nullable<T>.

U kunt een waarde in een vak van een waardetype T opheffen voor het bijbehorende type T?null-waarde, zoals in het volgende voorbeeld wordt weergegeven:

int a = 41;
object aBoxed = a;
int? aNullable = (int?)aBoxed;
Console.WriteLine($"Value of aNullable: {aNullable}");

object aNullableBoxed = aNullable;
if (aNullableBoxed is int valueOfA)
{
    Console.WriteLine($"aNullableBoxed is boxed int: {valueOfA}");
}
// Output:
// Value of aNullable: 41
// aNullableBoxed is boxed int: 41

Een type null-waarde identificeren

In het volgende voorbeeld ziet u hoe u kunt bepalen of een System.Type exemplaar een samengesteld null-waardetype vertegenwoordigt, dat wil weten het System.Nullable<T> type met een opgegeven typeparameter T:

Console.WriteLine($"int? is {(IsNullable(typeof(int?)) ? "nullable" : "non nullable")} value type");
Console.WriteLine($"int is {(IsNullable(typeof(int)) ? "nullable" : "non-nullable")} value type");

bool IsNullable(Type type) => Nullable.GetUnderlyingType(type) != null;

// Output:
// int? is nullable value type
// int is non-nullable value type

Zoals in het voorbeeld wordt weergegeven, gebruikt u de typeof-operator om een System.Type exemplaar te maken.

Als u wilt bepalen of een exemplaar van een null-waardetype is, gebruikt u de Object.GetType methode niet om een Type exemplaar op te halen om te testen met behulp van de voorgaande code. Wanneer u de Object.GetType methode aanroept op een exemplaar van een type null-waarde, wordt het exemplaar in een vak geplaatst.Object Omdat boksen van een niet-null-exemplaar van een type null-waarde gelijk is aan het boksen van een waarde van het onderliggende type, GetType retourneert een Type exemplaar dat het onderliggende type van een null-waardetype vertegenwoordigt:

int? a = 17;
Type typeOfA = a.GetType();
Console.WriteLine(typeOfA.FullName);
// Output:
// System.Int32

Gebruik ook niet de operator is om te bepalen of een exemplaar van een null-waardetype is. Zoals in het volgende voorbeeld wordt weergegeven, kunt u met behulp van de operator geen typen van een exemplaar van een null-waardetype en het is onderliggende typeexemplaren onderscheiden:

int? a = 14;
if (a is int)
{
    Console.WriteLine("int? instance is compatible with int");
}

int b = 17;
if (b is int?)
{
    Console.WriteLine("int instance is compatible with int?");
}
// Output:
// int? instance is compatible with int
// int instance is compatible with int?

Gebruik in plaats daarvan de Nullable.GetUnderlyingType methode uit het eerste voorbeeld en de typeof-operator om te controleren of een exemplaar van een null-waardetype is.

C#-taalspecificatie

Zie de volgende secties van de C#-taalspecificatie voor meer informatie:

• Null-typen
• Lifted operators
• Impliciete null-conversies
• Expliciete null-conversies
• Operators voor lifted conversie

Zie ook

• Wat betekent 'lifted' precies?
• System.Nullable<T>
• System.Nullable
• Nullable.GetUnderlyingType
• Null-verwijzingstypen