Sabemos que não existem tipos de valor (Value Types) nulos, mas o .NET 2.0 ou Superior suporta esse conceito, então vamos analisar um pouco sobre isso:

• Tipos que podem ser nulos

System.Int32?
System.Single?
System.Double?
System.Decimal?
System.Boolean?
System.SByte?
System.Int64?
System.Int16?
System.DateTime?
System.Guid?
System.Char?
System.UInt16
System.UInt32?
System.UInt64?

• Porque tipos nulos?

Vamos pensar em um cenário com uma classe Usuário.

Se a sua classe possui um campo (por exemplo Idade) que não é obrigatória, com fazer com que ela seja nula?

Bom, existem duas formas possíveis, vamos lá:

• Fazendo campo nulo sem tipos nulos

namespace ConsoleApplication1
{
    public class Usuario
    {
        public int Idade { get; set; }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Usuario meuUsuario = new Usuario();
            meuUsuario.Idade = int.MinValue; // Seta Idade como Nula
        }
    }
}

Convencionou-se que o menor valor possível de um Value Type indicaria que o campo é nulo. Usavamos essa técnica no tempo em que não existia o suporte a tipos Nulos.

• Fazendo campo nulo com tipo nulos

Com a criação dos tipos nulos, nosso código pode ficar assim:

namespace ConsoleApplication1
{
    public class Usuario
    {
        public int? Idade { get; set; }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Usuario meuUsuario = new Usuario();
            meuUsuario.Idade = null; // Seta Idade como Nula
        }
    }
}

• Respondendo o Porque de tipos nulos!

Bom, o motivo é simplemente porque é mais fácil de ler um código aonde se seta nulo para um campo do que um código onde se seja um valor (seja ele qual for) para ser considerado como nulo.

No fundo, o que faziamos era uma baita gambiarra!!

• Como funciona?

Na vida real ainda não existe suporte a Value Type nulo, o que foi feito é a criação de uma “struct” genérica (Nullable<T>) que suporta o controle de nulo.

Tanto é verdade que o código da classe “Usuario” poderia ser:

namespace ConsoleApplication1
{
    public class Usuario
    {
        public Nullable<int> Idade { get; set; }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Usuario meuUsuario = new Usuario();
            meuUsuario.Idade = null; // Seta Idade como Nula
        }
    }
}

A interrogação “?” apenas informa ao .Net utilizar a Struct genérica de uma forma transparente, pois, o motivo da criação dos Nullable Value Types era justamente facilitar, e ficar declarando variáveis com structs não ia ajudar na leitura do código, então, <MEUTIPO>? fica muito mais limpo de ler.

Até o Próximo.

Posts Relacionados:

1. Verificando se um tipo de objeto aceita valores nulos
2. Reflection – Parte 3 (Fields)
3. Por Dentro das Propriedades Automáticas
4. Reflection Parte 2 – Construtores
5. Reflection – Parte 4 (Propriedades)
6. .Net Framework Inside : Comparações Avançadas em .NET (IEquatable)
7. Ordenação de Listas (Coleções)