Tipos anuláveis

NULL literalmente não significa nada - uma variável que ainda não possui um valor. Neste ponto do tutorial, você pode já ter lidado com variáveis que não foram inicializadas, seja de propósito ou não - em caso afirmativo, você também sabe que precisa sempre ter certeza de que uma variável tem um valor antes de tentar acessar este valor. Caso contrário, você provavelmente encontrará uma NullReferenceException.

Nulos são especialmente importantes quando se lida com seus próprios objetos e strings. Do outro lado, quando lidando com números, ex.: um inteiro, você verá que eles sempre tem um valor (padrão). Para um inteiro, o valor padrão é 0 (zero), o que nunca deve ser confundido por nulo - eles não são todos os mesmos, ainda que algumas linguagens de programação que não sejam estaticamente tipadas possam tratar eles como o mesmo. 0 (zero) é um número - nulo é nada.

Então, se você alguma vez encontrar seu self querendo ter um número que represente um valor não-definido/NULL, você pode se sentir preso, porque você não pode atribuir null a uma variável inteira. A menos, claro, que o inteiro seja definido como anulável - uma construção de linguagem especial criada para situações como esta. Você define uma variável anulável por pós-fixação do tipo com um questionmark. Aqui está um exemplo para ilustrar a diferença:

int notNullable = null; // Will cause an error from the compiler

int? nullable = null; // Just fine - it's nullable!

Isso é válido para todos os chamados tipos de valor como números inteiros , flutuadores, bools e structs. Strings e objects, por outro lado, são tipos de referência e não podem ser declarados como anuláveis, porque são, por padrão, anuláveis.

Verificando um anulável por nulo

Portanto, agora que você definiu uma variável que pode ser nula, verificar se é esse o caso é obviamente importante. Você pode fazer isso de duas maneiras: Apenas compare a variável com a kewyord nula, como faria com qualquer outro tipo, ou use a propriedade HasValue que um objeto anulável herda da estrutura System.Nullable. Aqui está um exemplo:

int? nullable = null;  
if (nullable == null)  
    Console.WriteLine("It's a null!");  
if (!nullable.HasValue)  
    Console.WriteLine("It's a null!");

O resultado é o mesmo, então use o método que você achar mais legível e fácil de entender. Como o nosso valor agora pode ser nulo, você deve sempre verificar antes de usá-lo - caso contrário, você pode executar uma exceção.

Usando o valor de um valor anulável

Do System.Nullable, um objeto anulável também herda a propriedade Value . Isso pode ser usado para recuperar o valor real do objeto anulável. Contudo, para operações de comparação simples, e. Usando os operadores == e! =, o C # permite omitir a propriedade Value e comparar diretamente o objeto anulável. Em outras palavras, ambos os exemplos realizam a mesma coisa:

int? nullable = 42;

if (nullable.Value == 42)  
    Console.WriteLine("It's 42!");  

if (nullable == 42)  
    Console.WriteLine("It's 42!");

Objetos anuláveis sempre vêm de um tipo de dados de base, por exemplo um inteiro como nos exemplos anteriores. Embora esses tipos de dados possam ter um valor padrão, o valor padrão de um valor anulável é sempre nulo. É por isso que você precisa verificar referências nulas antes de tentar usar o valor, conforme descrito anteriormente. No entanto, um tipo anulável herda um método auxiliar muito agradável que você pode usar: GetValueOrDefault() . Ele retornará o valor do objeto anulável, a menos que seja nulo, caso em que retornará o valor padrão do tipo subjacente. Assim, para um inteiro anulável, retornaria 0, para um booleano anulável retornaria false e assim por diante. Isso permite que você manipule a verificação e a recuperação do valor em uma única instrução:

if ((nullable.HasValue) && (nullable.Value == 42))
    Console.WriteLine("It's 42!");

if(nullable.GetValueOrDefault() == 42)
    Console.WriteLine("It's 42!");

Como você pode ver, o último exemplo é mais curto e mais fácil de ler, enquanto realiza a mesma coisa.

Resumo

Tipos de valor em C #, como inteiros e booleanos, sempre têm um valor padrão. Se você quiser contornar esse comportamento, por exemplo porque você precisa diferenciar entre 0 e null, ou porque você precisa saber se o usuário ativamente selecionou " false " para algo ou se a variável apenas mantém o valor padrão de false , então você pode tornar a variável anulável por postfixing o tipo com um? (ponto de interrogação).