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

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 duas maneiras:

System.Nullable<T> variable

- ou -

T? variable

Té o tipo subjacente do tipo anulável. Tpode ser qualquer tipo de valor incluindo o 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, mais notavelmente 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 serã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 para 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, como o tipo subjacente. Se HasValue é true, Value contém um valor significativo. Se HasValue é false, acessando Value lançará um InvalidOperationException.

Neste exemplo, o HasValue membro é usado para testar se a variável contém um valor antes de tentar exibir o proprietário.

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

Também pode ser feito para um valor de teste 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 para 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 operandos forem nulos; Caso contrário, o operador usa o valor contido para 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.

A??Operador

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

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;

Bool?tipo

O bool? tipo anulável pode conter três valores diferentes: true, false and null. Para obter informações sobre como converter de um bool? para um bool, consulte How to: Converter de forma segura do bool? para bool (guia de programação C#).

Booleanos anuláveis são como o tipo de variável booleano que é usado em SQL. Para garantir que os resultados produzidos pela & e | 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:

Consulte também

Referência

Nullable Types (C# Programming Guide)

Boxing tipos anuláveis (C# guia de programação)

Conceitos

C# Programming Guide