Sexta .NET – Aula 12 – ASP.NET e C# – Parte III

Boa tarde, continuando a aula anterior conforme prometido, aqui vamos com:

Sexta .NET – Aula 12 – ASP.NET e C# – Parte III

Falaremos nesta aula sobre: Nullable Types

  • Recurso da versão 2.0.
  • Variáveis continuam a representar todos os valores do seu tipo, e mais um valor adicional null.
  • Permite uma integração melhor com bancos de dados, que podem conter valores null em seus campos.
  • Declaradas através da classe Nullable, ou através do operador ? adicionado ao tipo à ser utilizado.

Podem ser declaradas de duas formas:
System.Nullable variavel;
? variavel;

Onde T é o tipo da variável
Ambas notações funcionam de maneira equivalente
Declarando e usando uma variável inteira e anulável

int? clienteId;
clienteId = 10; //Ok
clienteId = null; //Ok, clienteId é anulável

Qualquer tipo por valor pode ser usado como Nullable Type

int? i = 10;
double? x = 3.14;
bool? flag = null;
char? letra = 'a';
int?[] MeuArray = new int?[10];

Os exemplos seguintes não são tipos por valor, portanto não são aceitáveis como Nullable Types

string? variavel = “tipos anulaveis”;
Cliente? umCliente = new Cliente?();

O operador as só pode ser utilizado com tipos por referência, então não pode ser usado com Nullable Types

int clienteId = 5;
object b = clienteId;
// Erro em tempo de compilação
int? c = b as int;

Uma instância de um tipo anulável possui duas propriedades read-only

  • HasValue: do tipo bool, retorna verdadeiro quando uma variável contém um valor não-nulo.
  • Value: do tipo equivalente ao tipo anulável utilizado, se HasValue é true, então Value contém um valor significativo, senão, ao tentar acessar Value será gerada uma exception.

Utilizando as propriedades de um tipo anulável

int? clienteId = 10;
if (clienteId.HasValue)
Console.WriteLine(clienteId.Value);
else
Console.WriteLine(“Identificação Indefinida!”);

Conversões explícitas

  • Um tipo anulável pode ser convertido para um tipo regular usando casts ou usando a propriedade Value.
  • Se o tipo anulável contém o valor null, será gerada uma exception.

Conversões explícitas

// Exemplos
int? clienteId = null;
// Não compila
int x = clienteId;
// Compila, mas será gerada uma exception se x for null
int x = (int)clienteId;
// Compila, mas será gerada uma exception se x for null
int x = clienteId.Value;

Conversões implícitas
A conversão de um tipo anulável para um tipo regular é implícita.

int produtosAdquiridos = 10;
// Conversão implícita
int? produtos = produtosAdquiridos;

Operadores
Quaisquer operadores existentes para tipos por valor podem ser utilizados com Nullable Types.
O operador produzirá null se os operandos forem nulos, caso contrário, usará o valor contido para calcular o resultado.

int? x = 10;
x++; // x agora é 11
x = x * 10; // x agora é 110
int? y = null;
x = x + y; // x agora é null

Quando são feitas comparações com Nullable Types, se ambos os Nullable Types são null, então a comparação sempre retornará false. O caso oposto retornará true.

int? x = 250;
int? produtosAdquiridos = null;
if (x >= produtosAdquiridos)
Console.WriteLine(“Adquiriu mais de {0} produtos.”,x);
else // Não é válido – Correto: adição de um else if (...)
Console.WriteLine(“Adquiriu menos de {0} produtos.”,x);

A conclusão contida na expressão else não é válida porque produtosAdquiridos é null, portanto, não contém nenhum valor. Logo, não pode ser maior ou menor que x.

O operador ??
Define um valor padrão que é retornado quando um tipo anulável é atribuído à um tipo não-anulável.

// Exemplo
int? produtosAdquiridos = null;
// Atribui o valor 0 à y se produtosAdquiridos for null
int y = produtosAdquiridos ?? 0;

Também pode ser utilizado com vários Nullable Types

int? limiteCredito;
int? valorDefault;
// Se limiteCredito não for null, z = limiteCredito.
// Se limiteCredito for null, z = valorDefault.
int? z = limiteCredito ?? valorDefault;

Na próxima aula falaremos sobre Coleções

Até a semana que vem!