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!
