C# Kombinierbare Typen (Nullable)

Es ist bekannt, dass null-Werte nicht den Wertetypen zugewiesen werden können. Zum Beispiel,int i = null würde ein Compilerfehler ausgelöst.

Definiton der Nullable-Typen

Nullable<int> i = null;

Nullable-Typen können den korrekten Wertebereich ihres Basistyps darstellen und zusätzlich einen zusätzlichen Leerwert. Zum Beispiel kann Nullable<int> Werte zuweisen von -2147483648 bis 2147483647 jeglichen Wert oder einen null-Wert.

Der Typ Nullable ist eine Instanz von System.Nullable<t> struct.

[Serializable]
public struct Nullable<T> where T : struct
{　　　　　　　　
　　　　public bool HasValue { get; }
　　　　　　
　　　　public T Value { get; }
　　　　　　　　
　　　　//　Andere Implementierungen
}

Der Typ Int ist mit dem regulären int-Typ identisch, mit einem Flag, das angibt, ob der int einen Wert hat (ob er null ist).... Der Rest ist Compiler-Zauber, der "null" als gültigen Wert ansieht.

static void Main(string[] args)
{
　　　　Nullable<int> i = null;
　　　　if (i.HasValue)
　　　　　　　　Console.WriteLine(i.Value);　//　oder Console.WriteLine(i)
　　　　else
　　　　　　　　Console.WriteLine("Null");
}

Null

Wenn das Objekt einen Wert zugewiesen hat, wird true zurückgegeben; wenn keine Werte zugewiesen wurden oder ein null-Wert zugewiesen wurde, wird false zurückgegeben.

Wenn der Typ von NullableType.value null ist oder keine Wert zugewiesen wurde, wird eine Laufzeit-Exception ausgelöst, wenn der Wert mit NullableType.value aufgerufen wird. Zum Beispiel, wenn i null ist, wird eine Ausnahme ausgelöst:

wenn er nicht null ist, dann Verwenden Sie die Methode GetValueOrDefault(), um den tatsächlichen Wert zu erhalten; wenn er null ist, wird der Standardwert verwendet. Zum Beispiel:

static void Main(string[] args)
{
　　　　Nullable<int> i = null;
　　　　Console.WriteLine(i.GetValueOrDefault());　
}

Kürzelige Syntax für nullable Typen

Sie können den Operator "？" verwenden, um die Syntax zu vereinfachen, z.B. int ?, long？statt von Nullable <T>.

int? i = null;
double? D = null;

Null-Kombinierungsoperator (??)

Verwenden Sie den Operator '？？', um einen nullable Typen einem nicht-nullable Typen zuzuweisen.

int? i = null;
　　　　　　　　　　　　
int j = i ?? 0;
Console.WriteLine(j);

0

Im obigen Beispiel ist i ein nullable int, wenn es einem nicht-nullable int j zugewiesen wird, wird eine Laufzeit-Exception ausgelöst, wenn i null ist. Daher verwenden wir den Operator "??", um 0 an j zu zuweisen, wenn i null ist, um das Risiko von Ausnahmen zu verringern.

using System;
namespace CalculatorApplication
{
　　　class NullablesAtShow
　　　{
　　　　　　　　　
　　　　　　static void Main(string[] args)
　　　　　　{
　　　　　　　　　
　　　　　　　　　double? num1　= null;
　　　　　　　　　double? num2　=　3.14157;
　　　　　　　　　double num3;
　　　　　　　　　num3　= num1　??　5.34;　　　　　　//　num1　wenn er ein leeres Wert ist, wird　5.34
　　　　　　　　　Console.WriteLine("num3　Wert: {0} 	 num3);
　　　　　　　　　num3　= num2　??　5.34;
　　　　　　　　　Console.WriteLine("num3　Wert: {0} 	 num3);
　　　　　　　　　Console.ReadLine();
　　　　　　}
　　　}
}

Ausgabeergebnis:

num3　Wert:　5.34
num3　Wert:　3.14157

Zuweisungsregeln

Die Zuweisungsregeln für nullable Typen sind gleich den Zuweisungsregeln für value Typen. Wenn ein nullable Typ in einer Funktion als lokaler Variablen deklariert wird, muss er vor seiner Verwendung zugewiesen werden. Wenn er ein Feld jeder Klasse ist, wird er in der Regel einen leeren Wert haben.

Beispiel, erklären und verwenden Sie den nullable int-Typ ohne eine beliebige Wertzuweisung. Der Compiler gibt„Verwenden Sie den nicht zugewiesenen lokalen Variablen ‘i’”Fehler:

Im folgenden Beispiel ist der nullable int-Typ dieses Feldes der Klasse, daher wird kein Fehler ausgelöst.

class MyClass
{
　　　　public Nullable<int> i;
}
class Program
{
　　　　static void Main(string[] args)
　　　　{
　　　　　　　　MyClass mycls = new MyClass();
　　　　　　　　if (mycls.i == null)
　　　　　　　　　　　　Console.WriteLine("Null");
　　　　}
}

Null

Vergleichsmethoden der Nullable-Klasse

Null wird als kleiner als jeder Wert betrachtet. Daher können Vergleichsoperatoren nicht für null verwendet werden. Sehen Sie sich das folgende Beispiel an, bei dem i weder kleiner noch größer als j ist, auch nicht gleich j:

static void Main(string[] args)
{
　　　　int? i = null;
　　　　int j =　10;
　　　　if (i < j)
　　　　　　　　Console.WriteLine("i < j");
　　　　else if (i >　10)
　　　　　　　　Console.WriteLine("i > j");
　　　　else if (i ==　10)
　　　　　　　　Console.WriteLine("i == j");
　　　　else
　　　　　　　　Console.WriteLine("Unvergleichlich");
}

Unvergleichlich

Die Nullable-Statische Klasse ist eine Hilfsklasse für den Nullable-Typ. Sie bietet Vergleichsmethoden für kannbare Typen. Sie verfügt auch über die Methode GetUnderlyingType, die den Basis-Typparameter des kannbaren Typs zurückgibt.

static void Main(string[] args)
{
　　　　int? i = null;
　　　　int j =　10;
　　　　if (Nullable.Compare<int>(i, j) < 0)
　　　　　　　　Console.WriteLine("i < j");
　　　　else if (Nullable.Compare<int>(i, j) > 0)
　　　　　　　　Console.WriteLine("i > j");
　　　　else
　　　　　　　　Console.WriteLine("i = j");
}

i < j

Eigenschaften der kannbaren Typen

1. Kannbare Typen können nur mit Wertetypen verwendet werden.

2. Wenn Value null ist, wirft die Value-Eigenschaft eine InvalidOperationException;否则返回值。

3. Wenn die Variable einen Wert enthält, gibt die HasValue-Eigenschaft true zurück; wenn sie null ist, gibt sie false zurück.

4. Nur die == und !=-Operatoren können mit leeren Typen verwendet werden. Für andere Vergleiche verwenden Sie die Nullable-Statische Klasse.

5. Verwendung von verschachtelten kombinierbaren Typen ist nicht erlaubt. Nullable <Nullable <int >> i; gibt ein Kompilierungsfehler aus.