Sdílet prostřednictvím

Typy hodnot s možnou hodnotou null (referenční dokumentace jazyka C#)

hodnoty s možnou hodnotou null představuje všechny hodnoty jeho základního T? hodnoty a další hodnotu null. Můžete například přiřadit k proměnné některou bool? z následujících tří hodnot: true, falsenebo null. Základní typ T hodnoty nemůže být samotný typ hodnoty null.

Referenční dokumentace jazyka C# dokumentuje naposledy vydané verze jazyka C#. Obsahuje také počáteční dokumentaci k funkcím ve verzi Public Preview pro nadcházející jazykovou verzi.

Dokumentace identifikuje všechny funkce, které byly poprvé představeny v posledních třech verzích jazyka nebo v aktuálních verzích Public Preview.

Návod

Informace o tom, kdy byla funkce poprvé představena v jazyce C#, najdete v článku o historii verzí jazyka C#.

Libovolný typ hodnoty null je instance obecné System.Nullable<T> struktury. Můžete odkazovat na typ hodnoty null s podkladovým typem T v některé z následujících zaměnitelných formulářů: Nullable<T> nebo T?.

Obvykle použijte typ hodnoty nullable, pokud potřebujete reprezentovat nedefinovanou hodnotu základního typu hodnoty. Například logická hodnota nebo boolproměnná může být true pouze nebo false. V některýchaplikacích Například pole databáze může obsahovat nebo false, nebo může obsahovat true žádnou hodnotu vůbec, to znamená NULL. Typ můžete použít bool? v tomto scénáři.

Deklarace a přiřazení

Vzhledem k tomu, že typ hodnoty je implicitně konvertibilní na odpovídající typ hodnoty null, můžete přiřadit hodnotu proměnné typu hodnoty s možnou hodnotou null, jak to uděláte pro jeho základní typ hodnoty. Můžete také přiřadit null hodnotu. Příklad:

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];

Výchozí hodnota typu hodnoty null představuje null. Je to instance, jejíž Nullable<T>.HasValue vlastnost vrací false.

Kontrola instance typu hodnoty s možnou hodnotou null

Pokud chcete zkontrolovat instanci typu null hodnoty null a získat hodnotu základního typu, použijte is operátor se vzorem typu:

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

Vždy můžete použít následující vlastnosti jen pro čtení ke kontrole a získání hodnoty proměnné typu nullable:

Následující příklad používá HasValue vlastnost ke kontrole, zda proměnná obsahuje hodnotu před zobrazením:

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

Můžete také porovnat proměnnou typu hodnoty s možnou hodnotou null namísto null použití HasValue vlastnosti, jak ukazuje následující příklad:

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

Převod typu hodnoty s možnou hodnotou null na podkladový typ

Pokud chcete přiřadit hodnotu typu hodnoty s možnou hodnotou null proměnné typu nenulnutelná, budete možná muset zadat hodnotu, kterou chcete přiřadit místo null. K tomu použijte operátor ??null-coalescing. Metodu Nullable<T>.GetValueOrDefault(T) můžete použít také pro stejný účel:

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

Pokud chcete použít výchozí hodnotu základního typu hodnoty místo null, použijte metodu Nullable<T>.GetValueOrDefault() .

Můžete také explicitně přetypovat typ hodnoty null na nenulový typ, jak ukazuje následující příklad:

int? n = null;

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

Pokud je nullhodnota typu hodnoty null za běhu, vyvolá explicitní přetypování hodnotu InvalidOperationException.

Typ T hodnoty, který není nullable, je implicitně konvertibilní na odpovídající typ T?hodnoty nullable .

Operátory se zvednutím

Typ T? hodnoty null podporuje předdefinované unární a binární operátory nebo jakékoli přetížené operátory, které typ T hodnoty podporuje. Tyto operátory, označované také jako lifted operátory, vrátí null , pokud jeden nebo oba operandy jsou null. V opačném případě operátor použije k výpočtu výsledku obsažené hodnoty svých operandů. Příklad:

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

Poznámka:

bool? U typu předdefinované & operátory a | operátory neodpovídají pravidlům popsaným v této části: výsledek vyhodnocení operátoru může být nenulový, i když je nullněkterý z operandů . Další informace naleznete v části logické operátory logické operátory s možnou hodnotou Null v článku logické operátory logických operátorů s možnou hodnotou Null.

Pro relační operátory< , >, <=a >=, pokud jeden nebo oba operandy jsou null, výsledek je false. V opačném případě se porovnávají hodnoty obsažených operandů. Nepředpokládáme, že protože konkrétní porovnání (například <=) vrátí false, opačné porovnání (>) vrátí true. Následující příklad ukazuje, že 10 je

  • ani větší než nebo rovno null
  • ani menší než 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

Pro operátor== rovnosti, pokud jsou nulloba operandy , výsledek je true. Pokud je pouze jeden z operandů null, výsledek je false. V opačném případě se porovnávají hodnoty obsažených operandů.

U operátoru!= nerovnosti platí, že pokud jsou nulloba operandy , výsledek je false. Pokud je pouze jeden z operandů null, výsledek je true. V opačném případě se porovnávají hodnoty obsažených operandů.

Pokud převod definovaný uživatelem existuje mezi dvěma typy hodnot, lze stejný převod použít také mezi odpovídajícími typy hodnot s možnou hodnotou null.

Boxování a rozbalování

Následující pravidla platí, když zadáte instanci typu T?hodnoty null:

  • Pokud HasValue se vrátí false, vrátí operace boxing odkaz null.
  • Pokud HasValue se vrátí true, boxovací operace pole odpovídající hodnotu základního typu Thodnoty , nikoli instance Nullable<T>.

Pole s hodnotou typu T hodnoty můžete rozbalit na odpovídající typ T?hodnoty null, jak ukazuje následující příklad:

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

Identifikace typu hodnoty s možnou hodnotou null

Následující příklad ukazuje, jak určit, zda System.Type instance představuje vytvořený typ hodnoty null, to znamená System.Nullable<T> typ se zadaným parametrem Ttypu:

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

Jak ukazuje příklad, použijete .

Pokud chcete zjistit, jestli je instance typu hodnoty null, nepoužívejte Object.GetType metodu Type k otestování instance pomocí předchozího kódu. Při volání Object.GetType metody u instance typu hodnoty nullable je instance boxed na Object. Vzhledem k tomu, že boxování instance nenulového typu hodnoty s možnou hodnotou null odpovídá boxování hodnoty základního typu, vrátí Type instanci, GetType která představuje základní typ hodnoty s možnou hodnotou null:

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

Nepoužívejte také operátor is k určení, zda instance je typu hodnoty null. Jak ukazuje následující příklad, nemůžete rozlišit typy typu hodnoty null a jeho základní typ instance pomocí operátoru is :

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?

Místo toho použijte metodu Nullable.GetUnderlyingType z prvního příkladu a typof operátoru ke kontrole, zda instance je typu hodnoty null.

Poznámka:

Metody popsané v této části se nevztahují na odkazové typy s možnou hodnotou null.

specifikace jazyka C#

Další informace najdete v následujících částech specifikace jazyka C#:

Viz také

  • Last updated on