Tipos de valor que permitem valor nulo: conceitos básicos de C#

Dica

Este artigo faz parte da seção Conceitos Básicos para desenvolvedores que conhecem pelo menos uma linguagem de programação e estão aprendendo C#. Se você é novo em programação, comece com os tutoriais Comece agora. Para obter mais detalhes, consulte tipos de valor anuláveis na referência de idioma.

Um tipo de T? representa todos os valores de seu tipo Tde valor subjacente, além de um valor adicionalnull. Uma variável de tipo int? contém qualquer inteiro ou null para representar "nenhum valor".

Tipos de valor, como int, boole DateTime não podem manter null por padrão. Esse comportamento é eficiente e evita muitos erros. No entanto, essa limitação cria um problema quando um valor pode estar genuinamente ausente. Um cenário comum é a leitura de um banco de dados: uma coluna de inteiro pode conter um número ou pode não conter nenhum valor (NULL no SQL). Um simples int não pode representar essa ausência, mas int? pode.

Declarar um tipo de valor anulável

Acrescente ? a qualquer tipo de valor para torná-lo anulável:

int?    age      = null;    // integer with no value yet
double? price    = 9.99;    // nullable double with a value
bool?   isActive = null;    // boolean with no value

age = 30;                   // assign a value later

int?[] scores = [100, null, 85, null, 72]; // array with absent entries

O valor padrão de um tipo de valor anulável é null. Não é o padrão do tipo subjacente.

Verificar se um valor está presente

A maneira recomendada de verificar um tipo de valor anulável e extrair seu valor é com um padrão de tipo:

int? temperature = 72;

if (temperature is int degrees)
{
    Console.WriteLine($"Temperature is {degrees}°F.");
}
else
{
    Console.WriteLine("Temperature is not recorded.");
}
// Output: Temperature is 72°F.

O is int degrees padrão corresponde somente quando temperature não é nulo e associa simultaneamente o valor a degrees. Você obtém tanto a verificação de nulidade quanto a extração de valor de uma só vez.

Como alternativa, use as propriedades HasValue e Value.

int? count = 42;

if (count.HasValue)
{
    Console.WriteLine($"Count is {count.Value}.");
}
else
{
    Console.WriteLine("Count has no value.");
}
// Output: Count is 42.

Prefira o is T value padrão para o novo código. Ele introduz uma nova variável não anulável com escopo para a ramificação correspondente, o que torna a intenção mais clara e elimina qualquer desejo de usar Value acidentalmente fora de uma verificação nula, em que um InvalidOperationException seria lançado.

Você também pode comparar diretamente com null:

int? quantity = null;

if (quantity != null)
{
    Console.WriteLine($"Quantity: {quantity.Value}");
}
else
{
    Console.WriteLine("Quantity is not set.");
}
// Output: Quantity is not set.

Obter um valor com um fallback

Quando você precisar de um valor não anulável a partir de um valor anulável, use GetValueOrDefault ou o operador de coalescência nula ??:

int? rating = null;

int result1 = rating.GetValueOrDefault();    // 0 (default for int)
int result2 = rating.GetValueOrDefault(-1);  // -1 (specified fallback)

Console.WriteLine(result1); // 0
Console.WriteLine(result2); // -1

rating = 5;
int result3 = rating.GetValueOrDefault(-1);  // 5 (actual value)
Console.WriteLine(result3); // 5

O operador ?? geralmente é mais eficiente quando usado inline.

int? priority = null;

int effective = priority ?? 0;  // 0 because priority is null
Console.WriteLine(effective);   // 0

priority  = 3;
effective = priority ?? 0;      // 3 because priority has a value
Console.WriteLine(effective);   // 3

Ambas as abordagens retornam o valor real quando um está presente e a alternativa que você especifica quando não estiver.

Aritmética com tipos de valor anuláveis

Operadores aritméticos e de comparação em tipos de valor anuláveis são elevados: quando um operando é null, o resultado é null em vez de um erro.

int? a = 10;
int? b = 20;
int? c = null;

int? sum     = a + b;   // both non-null: result is 30
int? product = a * c;   // one operand is null: result is null

Console.WriteLine(sum);               // 30
Console.WriteLine(product.HasValue);  // False — null propagates through arithmetic

O nulo se propaga por meio de aritmética por padrão. Para evitar que um resultado nulo se propague ainda mais, extraia o valor com ?? ou GetValueOrDefault antes de usá-lo em um cálculo.

Consulte também

  • Last updated on