Tipos nulos (Nullable) do C#

É conhecido que não é possível atribuir um valor nulo a tipos de valor. Por exemplo:int i = null lançará um erro de tempo de compilação.

Definição de tipo nullable

Nullable<int> i = null;

Os tipos nullable podem representar o intervalo correto de valores do tipo base, mais um valor extra de nulo. Por exemplo, Nullable<int> pode atribuir de -2147483648 até 2147483647 qualquer valor, ou um valor null.

O tipo Nullable é uma instância de System.Nullable<t> struct.

[Serializable]
public struct Nullable<T> where T : struct
{　　　　　　　　
　　　　public bool HasValue { get; }
　　　　　　
　　　　public T Value { get; }
　　　　　　　　
　　　　//　Outras implementações
}

O tipo Int nullable é idêntico ao tipo int normal, com um sinalizador que indica se o int tem um valor (se é null).... O resto são feitos por magia do compilador, ele considera 'null' como um valor válido.

static void Main(string[] args)
{
　　　　Nullable<int> i = null;
　　　　if (i.HasValue)
　　　　　　　　Console.WriteLine(i.Value);　//　ou Console.WriteLine(i)
　　　　else
　　　　　　　　Console.WriteLine("Null");
}

Null

Se o objeto já tiver um valor atribuído, retorna true; se não tiver nenhum valor atribuído ou tiver atribuído um valor null, retorna false.

Se o tipo NullableType.value for null ou não atribuir nenhum valor, usar NullableType.value para acessar o valor lançará uma exceção de tempo de execução. Por exemplo, se i for null, o valor lançará uma exceção:

Se não for null, então Use o método GetValueOrDefault() para obter o valor real; se for null, use o valor padrão. Por exemplo:

static void Main(string[] args)
{
　　　　Nullable<int> i = null;
　　　　Console.WriteLine(i.GetValueOrDefault());　
}

Sintaxe abreviada de tipo nullable

Você pode usar o operador '?' para simplificar a sintaxe, por exemplo int ?, long? em vez de usar Nullable <T>.

int? i = null;
double? D = null;

Operador de combinação de null (??)

Usando o operador '??', atribua tipos nullable a tipos não nullable.

int? i = null;
　　　　　　　　　　　　
int j = i ?? 0;
Console.WriteLine(j);

0

No exemplo acima, i é um int nullable, se atribuído a um int não nullable j, se i for null, ele lançará uma exceção de tempo de execução. Portanto, para reduzir o risco de exceções, usamos o operador '??', se i for null, atribuímos 0 a j.

using System;
namespace CalculatorApplication
{
　　　class NullablesAtShow
　　　{
　　　　　　　　　
　　　　　　static void Main(string[] args)
　　　　　　{
　　　　　　　　　
　　　　　　　　　double? num1　= null;
　　　　　　　　　double? num2　=　3.14157;
　　　　　　　　　double num3;
　　　　　　　　　num3　= num1　??　5.34;　　　　　　//　num1　Se for nulo, retorna　5.34
　　　　　　　　　Console.WriteLine("num3　O valor: {0}3);
　　　　　　　　　num3　= num2　??　5.34;
　　　　　　　　　Console.WriteLine("num3　O valor: {0}3);
　　　　　　　　　Console.ReadLine();
　　　　　　}
　　　}
}

Resultados de saída:

num3　O valor:　5.34
num3　O valor:　3.14157

Regras de atribuição

As regras de atribuição de tipos nullable são as mesmas que as de tipos de valor. Se declarar um tipo nullable como variável local em uma função, deve atribuir um valor a ela antes de usá-la. Se for um campo de qualquer classe, ele terá um valor nulo por padrão.

Por exemplo, declare e use o tipo int nullable sem atribuir nenhum valor. O compilador fornecerá“Uso do variável local não alocada 'i'”Erro:

No exemplo a seguir, o nullable do tipo int é um campo da classe, portanto, não haverá nenhum erro.

class MyClass
{
　　　　public Nullable<int> i;
}
class Program
{
　　　　static void Main(string[] args)
　　　　{
　　　　　　　　MyClass mycls = new MyClass();
　　　　　　　　if (mycls.i == null)
　　　　　　　　　　　　Console.WriteLine("Null");
　　　　}
}

Null

Métodos de comparação da classe Nullable

Null é considerado menor que qualquer valor. Portanto, os operadores de comparação não podem ser usados com null. Veja o seguinte exemplo, onde i nem é menor que j, nem maior que j, nem igual a j:

static void Main(string[] args)
{
　　　　int? i = null;
　　　　int j =　10;
　　　　if (i < j)
　　　　　　　　Console.WriteLine("i < j");
　　　　else if (i >　10)
　　　　　　　　Console.WriteLine("i > j");
　　　　else if (i ==　10)
　　　　　　　　Console.WriteLine("i == j");
　　　　else
　　　　　　　　Console.WriteLine("Impossível comparar");
}

Impossível comparar

A classe estática Nullable é uma classe auxiliar para o tipo Nullable. Ela fornece métodos de comparação para tipos nulos. Também possui o método GetUnderlyingType, que retorna o parâmetro do tipo base do tipo nullable que pode ser null.

static void Main(string[] args)
{
　　　　int? i = null;
　　　　int j =　10;
　　　　if (Nullable.Compare<int>(i, j) < 0)
　　　　　　　　Console.WriteLine("i < j");
　　　　else if (Nullable.Compare<int>(i, j) > 0)
　　　　　　　　Console.WriteLine("i > j");
　　　　else
　　　　　　　　Console.WriteLine("i = j");
}

i < j

Características do tipo nulo

1. Os tipos nulos podem ser usados apenas com tipos de valor.

2. Se o Value for null, a propriedade Value lançará um InvalidOperationException; caso contrário, retornará o valor.

3. Se a variável contiver um valor, a propriedade HasValue retorna true; se for null, retorna false.

4. Apenas os operadores == e != podem ser usados com tipos que podem ser nulos. Para outras comparações, use a classe estática Nullable.

5. Não é permitido usar tipos nulos aninhados. Nullable <Nullable <int>> i; gerará um erro de compilação.