Usando tipos anuláveis (C# Guia de programação)

Artigo
02/25/2013

Tipos anuláveis podem representar todos os valores de um tipo subjacente e adicional Nulo valor.Tipos anuláveis são declarados em uma das seguintes maneiras:

System.Nullable<T> variable

- ou -

T? variable

Té o tipo subjacente do tipo anulável.Tpode ser qualquer tipo de valor incluindo struct; ele não pode ser um tipo de referência.

Para obter um exemplo de quando você pode usar um tipo anulável, considere como uma variável booleana comum pode ter dois valores: true e false.Não há nenhum valor para o que significa "indefinidos".Em muitos aplicativos de programação, principalmente database interações, variáveis que podem ocorrer em um estado indefinido.Por exemplo, um campo em um banco de dados pode conter os valores true ou falsos, mas não pode também conter nenhum valor.Da mesma forma, os tipos de referência podem ser definidos como null para indicar que eles não são inicializados.

Esta disparidade pode criar o trabalho extra de programação, com variáveis adicionais usadas para armazenar informações de estado, o uso de valores especiais e assim por diante.O modificador do tipo anulável permite C# criar variáveis de tipo de valor que indicam um valor indefinido.

Exemplos de tipos anuláveis

Qualquer tipo de valor pode ser usado como base para um tipo anulável.Por exemplo:

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

Os membros de tipos anuláveis

Cada instância de um tipo anulável tem duas propriedades públicas de somente leitura:

HasValue

HasValueé do tipo bool.Ela é definida como true quando a variável contém um valor não nulo.
Value

Valueé do mesmo tipo que o tipo subjacente.Se HasValue é true, Value contém um valor significativo.If HasValue is false, accessing Value will throw a InvalidOperationException.

Neste exemplo, o HasValue membro é usado para testar se a variável contém um valor antes de tentar exibi-la.

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

Teste para um valor também pode ser feito como no exemplo a seguir:

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

Conversões explícitas

Um tipo anulável pode ser convertido em um tipo regular, explicitamente, com uma projeção ou usando o Value propriedade.Por exemplo:

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.

Se uma conversão definida pelo usuário é definida entre os dois tipos de dados, a mesma conversão também pode ser usada com as versões anuláveis desses tipos de dados.

Conversões implícitas

Uma variável do tipo anulável pode ser definida como null com o null palavra-chave, como mostrado no exemplo a seguir:

int? n1 = null;

A conversão de um tipo comum para um tipo anulável, está implícito.

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

Operadores

O unário predefinido e operadores binários e os operadores definidos pelo usuário que existem para tipos de valor também podem ser usados por tipos anuláveis.Esses operadores para produzir um valor nulo se os operandos forem nulos. Caso contrário, o operador usa o valor contido calcular o resultado.Por exemplo:

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.

Ao realizar comparações com tipos anuláveis, se o valor de um dos tipos anuláveis é nulo e o outro não, todas as comparações de avaliar a false , exceto para != (não igual).É importante não assumir que, como uma comparação particular retorna false, o caso oposto retorna true.No exemplo a seguir, 10 não é maior que, menor que nem igual a nulo.Somente num1 != num2 for avaliada como 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
 */

Uma comparação de igualdade de dois tipos anuláveis ambos nulo é avaliada como true.

O??Operador

O ?? operador define um valor padrão que é retornado quando um tipo anulável é atribuído a um tipo não anulável.

int? c = null;

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

Este operador também pode ser usado com vários tipos anuláveis.Por exemplo:

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;

O bool?tipo

O bool? tipo anulável pode conter três valores diferentes: true, false e Nulo.Para obter informações sobre como lançar um um bool?para um bool, consulte Como: com segurança a conversão da bool? para bool (C# Programming Guide).

Booleanos anuláveis são como o tipo de variável booleano que é usado em SQL.Para garantir que os resultados produzidos pela & e| os operadores são consistentes com o tipo booleano três valores no SQL, os seguintes operadores predefinidos são fornecidos:

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

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

Os resultados desses operadores estão listados na tabela a seguir:

X	y	x e y	x\|y
verdadeiro	verdadeiro	verdadeiro	verdadeiro
verdadeiro	FALSO	FALSO	verdadeiro
verdadeiro	Nulo	Nulo	verdadeiro
FALSO	verdadeiro	FALSO	verdadeiro
FALSO	FALSO	FALSO	FALSO
FALSO	Nulo	FALSO	Nulo
Nulo	verdadeiro	Nulo	verdadeiro
Nulo	FALSO	FALSO	Nulo
Nulo	Nulo	Nulo	Nulo