C#-Nullable-String

In C# gibt es zwei Arten von Variablen: Werttypen und Referenztypen. Variablen vom Werttyp können nicht null zugewiesen werden, wohingegen wir Referenztypvariablen null zuweisen können. Da es sich bei der Zeichenfolge um einen Referenztyp handelt, kann sie null sein. In diesem Thema lernen wir etwas über C# Nullable String.

Um einem Werttyp Null zuzuweisen, müssen wir Nullable verwenden. Struktur. Der nullbare Typ kann nur mit Werttypen verwendet werden, nicht mit Referenztypen. Daher können wir nullable nicht mit Zeichenfolgen verwenden. Wir können einen Nullwert anstelle eines Referenztyps speichern, um einen Nullwert zu speichern.

Syntax mit Erklärung

Die Syntax zum Zuweisen von Null zu einer Zeichenfolgenvariablen lautet wie folgt:

string str = null;

Hier ist str eine Variable vom Typ String und „null“ ist das Schlüsselwort, das zur Angabe des Nullwerts verwendet wird. In der obigen Anweisung weisen wir der Zeichenfolge null direkt zu, da es sich um einen Referenztyp handelt und einen Nullwert enthalten kann.

Nullable struct weist einem Werttyp null zu. Die Syntax lautet wie folgt:

Nullable<dataType> variableName = null;

Eine andere Möglichkeit, den Nullable-Typ zu verwenden, ist wie folgt:

dataType? variableName = null;

Der Datentyp ist der Datentyp eines beliebigen Werttyps in den beiden obigen Anweisungen, und Variablenname ist der benutzerdefinierte Name, der der Variablen gegeben wird.

Wie arbeite ich mit Nullable-Typ und Null-String in C#?

Nullable-Typ in C# weist Werttypvariablen wie Typ int, float, bool usw. Nullwerte zu, da sie keine Nullwerte speichern können. Andererseits können wir nullable nicht mit String oder einer anderen Referenztypvariablen verwenden, da diese direkt einen Nullwert speichern kann.

Ein nullbarer Typ ist nichts anderes als eine Instanz einer Struktur System.Nullable wobei T einen Werttyp des Datentyps darstellt. Beispielsweise können wir im nullbaren Typ „float“ „true“, „false“ und „null“ speichern. Wir können dies mit den folgenden Anweisungen verstehen:

//Die folgende Anweisung ist gültig, da wir null in nullable of bool speichern können

Nullable<bool> boolVal = null;

//die folgende Anweisung ist ungültig, da wir Null nicht in einer Variablen vom Typ bool speichern können

bool boolVal = null;

Wenn wir die obige Anweisung verwenden, erhalten wir die Fehlermeldung „Null kann nicht in Bool konvertiert werden, da es sich um einen nicht nullbaren Werttyp handelt.“

Eine andere Möglichkeit, einen Nullable-Typ zu erstellen, ist die Verwendung des „?“-Operators, wie unten gezeigt:

bool? boolVal = null;

Um nun auf den Wert eines nullbaren Typs zuzugreifen, müssen wir die Methode GetValueOrDefault() verwenden. Mit Hilfe dieser Methode erhalten wir den ursprünglich zugewiesenen Wert, wenn der Wert nicht null ist. Wenn der Wert hingegen null ist, erhalten wir den Standardwert Null.

Abgesehen davon können wir Nullable.HasValue verwenden, um zu überprüfen, ob dem Objekt ein Wert zugewiesen wurde oder nicht. Wenn dem Objekt ein Wert zugewiesen wurde, wird „true“ zurückgegeben, wenn das Objekt keinen Wert enthält.

Wir können den Nullable-Typ nicht mit „var“ verwenden und wir können keinen verschachtelten Nullable-Typ haben; es wird uns einen Fehler bei der Kompilierung geben.

Lassen Sie uns nun über die Nullzeichenfolge in C# sprechen. Wir können einer Zeichenfolge in C# direkt Null zuweisen und mit „string“ eine Zeichenfolge zuweisen. „Leer“ ist ein schreibgeschütztes Feld, das angibt, dass die Zeichenfolge leer ist.

Wir können keine Methoden für die Nullzeichenfolge aufrufen und keine Zeichenfolgeneigenschaften für die Nullzeichenfolge verwenden, während wir dasselbe mit leeren Zeichenfolgen tun können. Wenn wir beispielsweise die Länge einer leeren Zeichenfolge mithilfe einer Zeichenfolge überprüfen. Längen-Eigenschaft, dann erhalten wir das Ergebnis als Null. Wenn wir hingegen die Länge einer Nullzeichenfolge überprüfen, erhalten wir eine Laufzeitausnahme mit der Meldung „System.NullReferenceException: Objektreferenz nicht auf eine Instanz eines Objekts festgelegt“. Wir erhalten die gleiche Ausnahme, wenn wir versuchen, eine beliebige String-Methode für einen Null-String aufzurufen. Dies liegt daran, dass eine Nullzeichenfolge keine Instanz eines Systems ist. Zeichenfolge. Wir können dies anhand der folgenden Aussagen verstehen:

Beispiel für eine leere Zeichenfolge:

string str = string.Empty;
int a = str.Length; //the result of this statement will be zero

Beispiel für eine Nullzeichenfolge:

string str = null;
int a = str.Length; //this statement will give NullReferenceException

Beispiele für C#-Nullable-Strings

Verschiedene Beispiele sind unten aufgeführt:

Beispiel #1

Beispiel, das zeigt, wie ein nullfähiger Typ erstellt wird.

Code:

using System;
namespace ConsoleApp4
{
public class Program
{
public static void Main()
{
try
{
//defining nullable type for int
Nullable<int> intVal1 = null;
int result1;
Nullable<int> intVal2 = 53;
int result2;
//using GetValueOrDefault()
//to get value from nullable type
result1 = intVal1.GetValueOrDefault();
result2 = intVal2.GetValueOrDefault();
Console.WriteLine("Integer having null: {0}", result1);
Console.WriteLine("Integer having value: {0}", result2);
}
catch(Exception exception)
{
Console.WriteLine(exception.Message);
Console.ReadLine();
}
Console.ReadLine();
}
}
}

Ausgabe:

Beispiele #2

Zum Beispiel wird mit dem Operator „?“ ein nullbarer Typ erstellt und mit HasValue geprüft, ob er einen Wert enthält oder nicht.

Code:

using System;
public class Program
{
public static void Main()
{
try
{
//defining nullable type
//using '?' operator
int? intVal1 = null;
bool result1;
int? intVal2 = 53;
bool result2;
//using HasValue to check
// if the object has been assigned a value or not
result1 = intVal1.HasValue;
result2 = intVal2.HasValue;
Console.WriteLine("Integer having null: {0}", result1);
Console.WriteLine("Integer having value: {0}", result2);
}
catch (Exception exception)
{
Console.WriteLine(exception.Message);
Console.ReadLine();
}
Console.ReadLine();
}
}

Ausgabe:

Beispiel #3

Beispiel zur Überprüfung, ob eine Zeichenfolge null oder leer ist oder einen Wert enthält, mithilfe der IsNullOrEmpty()-Methode.

Code:

using System;
public class Program
{
public static void Main()
{
string str1 = null;
string str2 = string.Empty;
string str3 = "Learning C#";
Console.WriteLine("str1 is null or empty: {0}", string.IsNullOrEmpty(str1));
Console.WriteLine("str2 is null or empty: {0}", string.IsNullOrEmpty(str2));
Console.WriteLine("str3 is null or empty: {0}", string.IsNullOrEmpty(str3));
Console.ReadLine();
}
}

Ausgabe:

Fazit

In C# können Werttypvariablen wie Variablen vom Typ int, float, bool, double usw. keinen Nullwert speichern, wohingegen Referenztypvariablen wie String Nullwerte speichern können. Um Nullwerte in Werttypvariablen zu speichern, können wir Nullable verwenden. Struktur.

Das obige ist der detaillierte Inhalt vonC#-Nullable-String. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!