Verwenden von auf NULL festlegbaren Typen (C# Programmierhandbuch)Using Nullable Types (C# Programming Guide)

Auf NULL festlegbare Typen können alle Werte eines zugrundeliegenden Typs und einen zusätzlichen NULL-Wert darstellen.Nullable types can represent all the values of an underlying type, and an additional null value. Auf NULL festlegbare Typen können auf zwei verschiedene Arten deklariert werden:Nullable types are declared in one of two ways:

System.Nullable<T> variable

- oder - -or-

T? variable

T ist der zugrundeliegende Typ des Typs, der NULL-Werte zulässt.T is the underlying type of the nullable type. T kann jeder Werttyp, auch struct, sein; allerdings kann es kein Verweistyp sein.T can be any value type including struct; it cannot be a reference type.

Denken Sie z.B. an eine normalen Boolesche Variable, die zwei Werte aufweisen kann: TRUE und FALSE; so ähnlich verhält es sich auch mit dem Einsatz eines Typs, der NULL-Werte zulässt.For an example of when you might use a nullable type, consider how an ordinary Boolean variable can have two values: true and false. Es gibt keinen Wert, der für „nicht definiert“ steht.There is no value that signifies "undefined". In den meisten Programmierungsanwendungen – allen voran Datenbankinteraktionen – können Variablen in einem nicht definierten Zustand vorkommen.In many programming applications, most notably database interactions, variables can occur in an undefined state. Ein Feld in einer Datenbank kann z.B. die Werte TRUE und FALSE enthalten; ebenso kann es aber auch gar keinen Wert enthalten.For example, a field in a database may contain the values true or false, but it may also contain no value at all. Ebenso können Verweistypen auf null festgelegt werden, um zu kennzeichnen, dass sie nicht initialisiert wurden.Similarly, reference types can be set to null to indicate that they are not initialized.

Durch diese Ungleichheit kann weiteres Programmieren erforderlich sein: zusätzliche Variablen zum Speichern von Zustandsinformationen, der Einsatz von besonderen Werten usw.This disparity can create extra programming work, with additional variables used to store state information, the use of special values, and so on. Mit dem Modifizierer für Typen, die NULL-Werte zulassen, kann C# value-type-Variablen erstellen, die einen nicht definierten Wert kennzeichnen.The nullable type modifier enables C# to create value-type variables that indicate an undefined value.

Beispiele für Typen, die NULL-Werte zulassenExamples of Nullable Types

Jeder Werttyp kann als Grundlage für einen Typ, der NULL-Werte zulässt, verwendet werden.Any value type may be used as the basis for a nullable type. Zum Beispiel:For example:

int? i = 10;
double? d1 = 3.14;
bool? flag = null;
char? letter = 'a';
int?[] arr = new int?[10];

Member von Typen, die NULL-Werte zulassenThe Members of Nullable Types

Jede Instanz eines Typs, der auf NULL festgelegt werden kann, hat zwei öffentliche schreibgeschützte Eigenschaften:Each instance of a nullable type has two public read-only properties:

  • HasValue

    HasValue ist vom Typ bool.HasValue is of type bool. Es wird auf true festgelegt, wenn die Variable einen Wert enthält, der ungleich NULL ist.It is set to true when the variable contains a non-null value.

  • Value

    Value hat denselben Typ wie der zugrunde liegende Typ.Value is of the same type as the underlying type. Wenn HasValue true ist, enthält Value einen sinnvollen Wert.If HasValue is true, Value contains a meaningful value. Wenn HasValue auf false festgelegt ist, wird bei Zugriff auf Value eine InvalidOperationException ausgelöst.If HasValue is false, accessing Value will throw a InvalidOperationException.

Der HasValue-Member in diesem Beispiel wird dazu verwendet, zu prüfen, ob eine Variable einen Wert enthält, bevor er diesen anzeigt.In this example, the HasValue member is used to test whether the variable contains a value before it tries to display it.

int? x = 10;
if (x.HasValue)
{
    System.Console.WriteLine(x.Value);
}
else
{
    System.Console.WriteLine("Undefined");
}

Das Prüfen auf einen Wert kann auch wie im folgenden Beispiel durchgeführt werden:Testing for a value can also be done as in the following example:

int? y = 10;
if (y != null)
{
    System.Console.WriteLine(y.Value);
}
else
{
    System.Console.WriteLine("Undefined");
}

Explizite KonvertierungenExplicit Conversions

Ein Typ, der NULL-Werte zulässt, kann in einen gängigen Typ umgewandelt werden; dies können Sie entweder durch eine explizite Umwandlung oder mithilfe der Value-Eigenschaft erzielen.A nullable type can be cast to a regular type, either explicitly with a cast, or by using the Value property. Zum Beispiel:For example:

int? n = null;

//int m1 = n;      // Will not compile.
int m2 = (int)n;   // Compiles, but will create an exception if n is null.
int m3 = n.Value;  // Compiles, but will create an exception if n is null.

Wenn eine benutzerdefinierte Konvertierung zwischen zwei Datentypen definiert ist, kann die gleiche Konvertierung auch mit der Version dieser Datentypen verwendet werden, die NULL-Werte zulassen.If a user-defined conversion is defined between two data types, the same conversion can also be used with the nullable versions of these data types.

Implizite KonvertierungenImplicit Conversions

Eine Variable mit einem Typ, der NULL-Werte zulässt, kann wie in folgendem Beispiel mit dem Schlüsselwort null auf NULL festgelegt werden:A variable of nullable type can be set to null with the null keyword, as shown in the following example:

int? n1 = null;

Die Konvertierung von einem gängigen in einen auf NULL-festlegbaren Typ ist implizit.The conversion from an ordinary type to a nullable type, is implicit.

int? n2;
n2 = 10;  // Implicit conversion.

OperatorenOperators

Die vordefinierten unären und binären Operatoren und alle benutzerdefinierten Operatoren für Werttypen können auch von auf NULL festlegbaren Typen verwende werden.The predefined unary and binary operators and any user-defined operators that exist for value types may also be used by nullable types. Die Operatoren erzeugen einen NULL-Wert, wenn die Operanden NULL sind; andernfalls verwenden die Operatoren den enthaltenen Wert zur Berechnung eines Ergebnisses.These operators produce a null value if the operands are null; otherwise, the operator uses the contained value to calculate the result. Zum Beispiel:For example:

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

a++;         // Increment by 1, now a is 11.
a = a * 10;  // Multiply by 10, now a is 110.
a = a + b;   // Add b, now a is null.

Wenn Sie Vergleiche mit auf NULL-festlegbaren Typen durchführen, ergeben alle Vergleiche false, nur != nicht (ungleich), wenn der Wert von lediglich einem auf NULL festlegbaren Wert NULL ist.When you perform comparisons with nullable types, if the value of one of the nullable types is null and the other is not, all comparisons evaluate to false except for != (not equal). Es ist wichtig, dass Sie nicht davon ausgehen, dass der entgegengesetzte Fall true zurückgeben würde, nur wenn ein Vergleich false zurückgibt.It is important not to assume that because a particular comparison returns false, the opposite case returns true. Im folgenden Beispiel ist 10 weder größer noch kleiner noch gleich NULL.In the following example, 10 is not greater than, less than, nor equal to null. Nur num1 != num2 ergibt true.Only num1 != num2 evaluates to true.

int? num1 = 10;
int? num2 = null;
if (num1 >= num2)
{
    Console.WriteLine("num1 is greater than or equal to num2");
}
else
{
    // This clause is selected, but num1 is not less than num2.
    Console.WriteLine("num1 >= num2 returned false (but num1 < num2 also is false)");
}

if (num1 < num2)
{
    Console.WriteLine("num1 is less than num2");
}
else
{
    // The else clause is selected again, but num1 is not greater than
    // or equal to num2.
    Console.WriteLine("num1 < num2 returned false (but num1 >= num2 also is false)");
}

if (num1 != num2)
{
    // This comparison is true, num1 and num2 are not equal.
    Console.WriteLine("Finally, num1 != num2 returns true!");
}

// Change the value of num1, so that both num1 and num2 are null.
num1 = null;
if (num1 == num2)
{
    // The equality comparison returns true when both operands are null.
    Console.WriteLine("num1 == num2 returns true when the value of each is null");
}

/* Output:
 * num1 >= num2 returned false (but num1 < num2 also is false)
 * num1 < num2 returned false (but num1 >= num2 also is false)
 * Finally, num1 != num2 returns true!
 * num1 == num2 returns true when the value of each is null
 */

Ein Gleichheitsvergleich zweier auf NULL festlegbarer Typen, die beide NULL sind, ergibt true.An equality comparison of two nullable types that are both null evaluates to true.

Der ??-The ?? OperatorOperator

Der ??-Operator definiert einen Standardwert, der zurückgegeben wird, wenn ein auf NULL festlegbarer Typ einem nicht auf NULL festlegbaren Typ zugewiesen wird.The ?? operator defines a default value that is returned when a nullable type is assigned to a non-nullable type.

int? c = null;

// d = c, unless c is null, in which case d = -1.
int d = c ?? -1;

Dieser Operator kann auch mit mehreren auf NULL festlegbaren Typen verwendet werden.This operator can also be used with multiple nullable types. Zum Beispiel:For example:

int? e = null;
int? f = null;

// g = e or f, unless e and f are both null, in which case g = -1.
int g = e ?? f ?? -1;

Der „bool?“-TypThe bool? type

Der bool?-Typ, der NULL-Werte zulässt, kann drei verschiedene Werte enthalten: TRUE, FALSE und NULL.The bool? nullable type can contain three different values: true, false and null. Weitere Informationen zur Umwandlung von „bool?“ in „bool“ finden Sie unter Vorgehensweise: Sichere Umwandlung von bool? in bool.For information about how to cast from a bool? to a bool, see How to: Safely Cast from bool? to bool.

Boolesche Werte, die auf NULL festgelegt werden können, verhalten sich ähnlich wie der in SQL verwendete Boolesche Variablentyp.Nullable Booleans are like the Boolean variable type that is used in SQL. Folgende vordefinierte Operatoren stehen zur Verfügung, um sicherzustellen, dass die von den Operatoren & und | erzeugten Ergebnisse zu dem dreiwertigen Booleschen Typ in SQL passen:To ensure that the results produced by the & and | operators are consistent with the three-valued Boolean type in SQL, the following predefined operators are provided:

bool? operator &(bool? x, bool? y)

bool? operator |(bool? x, bool? y)

Die Ergebnisse dieser Operatoren sind in der folgenden Tabelle aufgeführt:The results of these operators are listed in the following table:

XX uy x&yx&y x|yx|y
truetrue truetrue truetrue truetrue
truetrue falsefalse falsefalse truetrue
truetrue NULLnull NULLnull truetrue
falsefalse truetrue falsefalse truetrue
falsefalse falsefalse falsefalse falsefalse
falsefalse NULLnull falsefalse NULLnull
NULLnull truetrue NULLnull truetrue
NULLnull falsefalse falsefalse NULLnull
NULLnull NULLnull NULLnull NULLnull

Siehe auchSee Also

C#-ProgrammierhandbuchC# Programming Guide
Typen mit NullwertNullable Types
Boxing von Typen mit NullwertenBoxing Nullable Types
Auf NULL festlegbare WerttypenNullable Value Types