C# - Você acha que conhece bem a linguagem C# ?

 Hoje veremos se você conhece mesmo a linguagem C#.

Embora a linguagem  C# seja considerada uma linguagem fácil de aprender e entender, o código escrito pode se comportar de maneira inesperada às vezes, mesmo para desenvolvedores com anos de experiência e bom conhecimento da linguagem.

Este artigo apresenta alguns trechos de código que se enquadram nessa categoria e explica as razões por trás do comportamento (às vezes surpreendente) que a C# apresenta.

Começando com o famigerado Null

Afinal o que é null ?

A documentação diz o seguinte:

A palavra-chave null é um literal que representa uma referência nula, uma que não se refere a nenhum objeto.

Obs : A partir da versão 2.0 da linguagem foram introduzidos os tipos anuláveis ou nullable types.

Assim, null é diferente de zero(0) , é diferente de uma string vazia ("") , e,  é diferente de uma variável que não foi inicializada (empty); o null é alguma coisa indefinida...

Assim, o código abaixo terá como resultado o valor null para a , b e c :

var a = null - null;       // é igual a null  é não igual a zero ( 0 )
var b = null + 7;         // é igual a null e não igual a 7
var c = null * null;       // é igual a null

Estamos todos conscientes de que valores nulos podem ser perigosos, se não forem manipulados adequadamente.

Se você chamar um método ou acessar uma propriedade de uma variável de valor null vai obter uma exceção NullReferenceException conforme mostra o código a seguir:

Dessa forma devemos sempre ter certeza de que os valores do tipo de referência não são null antes de acessá-los ou referenciá-los.

Mesmo usando Reflection para tentar obter o tipo, ao usar GetType() em um valor null vai obter o mesmo NullReferenceException.

object nullValor = null;
Type tipoNull = nullValor.GetType();

Vejamos agora um trecho de código abaixo:

No código acima definimos a explicitamente variável nullString como string e usamos o operador is para verificar se o tipo é uma string.

Qual será o valor da variável tipoString ?

Será que o valor de uma variável explicitamente tipada como string sempre será tipada como string em tempo de execução ?

Qual a sua resposta ?

Executando o código no modo Debug e verificando o valor de tipoString teremos que o seu valor é false. Ou seja nullString não é uma string.

Então a resposta correta é não.

Mas como ?  Por quê ???

Simplesmente porque um valor null não possui nenhum tipo em tempo de execução.

Agora vamos declarar um variável int valorInt e uma outra variável do tipo anulável ou nullable valorNullableInt :

 

Será possível distinguir entre valorInt e valorNullableInt ?

Executando o código no modo Debug veremos que o valor de tiposIguais é true :



Assim, a resposta é não.

O mesmo tipo, System.Int32 , será retornado para as duas variáveis.

Mas, isso não significa que os tipos anuláveis não tenham uma representação usando Reflection.

Veja agora este outro código:

Agora os tipos são diferentes como era esperado.

Sendo que tipoInt é do tipo System.Int32  enquanto que tipoNullableInt é do tipo System.Nullable`1 [[System.Int32]].

Dessa forma somente ao inspecionar valores, os tipos anuláveis ​​são tratados da mesma forma que os não-anuláveis ​​usando Reflection.

Você já conhecia esse comportamento do null na linguagem C# ?

Em outro artigo vamos continuar a explorar outros aspectos não tão conhecidos da linguagem C#.

Aguarde...

"Porque Cristo não entrou num santuário feito por mãos, figura do verdadeiro, porém no mesmo céu, para agora comparecer por nós perante a face de Deus;"
Hebreus 9:24

Veja os Destaques e novidades do SUPER DVD Visual Basic (sempre atualizado) : clique e confira !

Quer migrar para o VB .NET ?

Quer aprender C# ??

Quer aprender os conceitos da Programação Orientada a objetos ?

Quer aprender o gerar relatórios com o ReportViewer no VS 2013 ?

Referências:

José Carlos Macoratti