Použití typů s možnou hodnotou Null (C# programování Guide)

Článek
05/01/2013

Typy s možnou hodnotou NULL mohou představovat všechny hodnoty základního typu a dalších null hodnotu.S možnou hodnotou Null typy jsou deklarovány v dvěma způsoby:

System.Nullable<T> variable

-nebo-

T? variable

Tje základní typ s možnou hodnotou Null typu.Tmůže být libovolný typ hodnoty včetně struct; nemůže být typu odkazu.

Příkladem může být při použití s možnou hodnotou Null typu zvažte jak běžným Logická proměnná může obsahovat dvě hodnoty: true a false.Žádnou hodnotu, která je "undefined".V mnoha programovacích aplikací zejména databáze interakcí, proměnné může dojít v nedefinovaný stav.Například pole v databázi mohou obsahovat hodnoty true nebo false, ale může také obsahovat žádná hodnota vůbec.Podobně lze nastavit typy odkazů na null označuje, že není inicializován.

Tato rozdílnost vytvořit extra programovací práce s další proměnné, které se používají k uložení informací o stavu, použití speciální hodnoty atd.Typ s možnou hodnotou Null modifikátor umožňuje C# vytváření proměnných typ hodnoty, které označují nedefinovanou hodnotu.

Příklady typů s možnou hodnotou Null

Typ libovolné hodnoty mohou sloužit jako základ pro typ s možnou hodnotou Null.Příklad:

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

Členové typy s možnou hodnotou Null

Každá instance s možnou hodnotou Null typu má dvě veřejné vlastnosti pouze pro čtení:

HasValue

HasValuetyp je bool.Je nastavena na true Pokud proměnná obsahuje hodnotu než null.
Value

Valueje stejného typu jako základního typu.Pokud HasValue je true, Value obsahuje výstižnější.If HasValue is false, accessing Value will throw a InvalidOperationException.

V tomto příkladu HasValue členských slouží k testování, zda proměnná obsahuje hodnotu dříve, než se pokusí jej zobrazit.

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

Testování hodnoty lze provést také jako v následujícím příkladu:

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

Explicitní převody

Typ s možnou hodnotou Null můžete obsadit pravidelné typu, výslovně se cast nebo pomocí Value vlastnost.Příklad:

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.

Pokud je definován uživatelem definovaný převod mezi dva datové typy, stejný převod lze také s verzemi těchto datových typů s možnou hodnotou Null.

Implicitní převody

S možnou hodnotou Null typu proměnné lze nastavit na hodnotu null s null klíčové slovo, jak ukazuje následující příklad:

int? n1 = null;

Je implicitní převod běžných typ s možnou hodnotou Null typu.

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

Operátory

Předdefinované unárních a binárních operátorů a operátory definované uživatelem, které existují pro typy hodnot může také použít typy s možnou hodnotou Null.Těchto operátorů získáte hodnotu null, pokud jsou operandy null. jinak provozovatel použije obsažené hodnoty výpočtu výsledků.Příklad:

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.

Při provádění porovnávání s typy s možnou hodnotou Null, pokud jeden z typů s možnou hodnotou Null hodnotu null a ostatní není vyhodnoceny všechny porovnání false s výjimkou != (není rovno).Je důležité, abyste předpokládat, protože zejména srovnání false, opačném případě vrátí true.V následujícím příkladu 10 není větší než, menší než ani rovna null.Pouze num1 != num2 vyhodnocen jako 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
 */

Porovnávání rovnost dvou typů s možnou hodnotou Null, které jsou obě hodnotu null vyhodnocen jako true.

Na??Operátor

?? Operátor definuje výchozí hodnotu, která vrátí typ s možnou hodnotou NULL je přiřazen typ Structure.

int? c = null;

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

Tento operátor lze také použít s více typy s možnou hodnotou Null.Příklad:

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;

Bool?typ

bool? Typ s možnou hodnotou Null může obsahovat tři různé hodnoty: true, false a null.Informace o tom, jak převést bool?k bool, viz Jak: bezpečně nádech z bool? k bool (C# program televize).

S možnou hodnotou Null logické hodnoty jsou jako logická typ proměnné, použité v SQL.Zajistit, aby výsledky vyrobené & a| operátory jsou konzistentní s hodnotou tři typu Boolean v SQL, jsou k dispozici následující předdefinované operátory:

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

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

V následující tabulce jsou uvedeny výsledky těchto operátorů:

X	y	x a y	x\|y
true	true	true	true
true	false	false	true
true	Null	Null	true
false	true	false	true
false	false	false	false
false	Null	false	Null
Null	true	Null	true
Null	false	false	Null
Null	Null	Null	Null