Por que há uma diferença em verificar nulo em relação a um valor em VB.NET e C #?

Em VB.NET isso acontece:

Dim x As System.Nullable(Of Decimal) = Nothing
Dim y As System.Nullable(Of Decimal) = Nothing

y = 5
If x <> y Then
    Console.WriteLine("true")
Else
    Console.WriteLine("false") '' <-- I got this. Why?
End If

Mas em C # isso acontece:

decimal? x = default(decimal?);
decimal? y = default(decimal?);

y = 5;
if (x != y)
{
    Debug.WriteLine("true"); // <-- I got this -- I'm with you, C# :)
}
else
{
    Debug.WriteLine("false");
}

Por que existe uma diferença?

VB.NET e C # .NET são linguagens diferentes, construídas por equipes diferentes que fizeram suposições diferentes sobre o uso; neste caso, a semântica de uma comparação NULL.

Minha preferência pessoal é pela semântica VB.NET, que em essência dá a NULL a semântica "Eu não sei ainda". Em seguida, a comparação de 5 com "Não sei ainda". é naturalmente "Não sei ainda"; ou seja, NULL. Isso tem a vantagem adicional de espelhar o comportamento de NULL na maioria dos bancos de dados SQL (se não em todos). Esta também é uma interpretação mais padrão (do que C #) da lógica de três valores, conforme explicado aqui .

A equipe C # fez diferentes suposições sobre o que NULL significa, resultando na diferença de comportamento que você mostra. Eric Lippert escreveu um blog sobre o significado de NULL em C # . Por Eric Lippert: "Eu também escrevi sobre a semântica de nulos em VB / VBScript e JScript aqui e aqui ".

Em qualquer ambiente no qual valores NULL são possíveis, é importante reconhecer que a Lei do Meio Excluído (isto é, que A ou ~ A é tautologicamente verdadeiro) não pode mais ser confiável.

Atualizar:

A bool(ao contrário de a bool?) só pode assumir os valores TRUE e FALSE. No entanto, uma implementação de linguagem de NULL deve decidir como NULL se propaga por meio de expressões. Em VB, as expressões 5=nulle 5<>nullAMBOS retornam falso. Em C #, das expressões comparáveis 5==nulle 5!=nullapenas a segunda primeira [atualizado em 02/03/2014 - PG] retorna falso. Entretanto, em QUALQUER ambiente que suporte nulo, é responsabilidade do programador saber as tabelas de verdade e propagação de nulos usadas por aquela linguagem.

Atualizar

Os artigos do blog de Eric Lippert (mencionados em seus comentários abaixo) sobre semântica estão agora em:

• 30 de setembro de 2003 - A Whole Lot of Nothing

• 1º de outubro de 2003 - Um pouco mais sobre nada

Porque x <> yretorna em Nothingvez de true. Simplesmente não está definido, pois xnão está definido. (semelhante a SQL null).

Nota: VB.NET Nothing<> C # null.

Você também deve comparar o valor de a Nullable(Of Decimal)apenas se ele tiver um valor.

Portanto, o VB.NET acima se compara a este (que parece menos incorreto):

If x.HasValue AndAlso y.HasValue AndAlso x <> y Then
    Console.WriteLine("true")
Else
    Console.WriteLine("false")  
End If

A especificação da linguagem VB.NET :

7.1.1 Tipos de valor anulável ... Um tipo de valor anulável pode conter os mesmos valores que a versão não anulável do tipo, bem como o valor nulo. Portanto, para um tipo de valor anulável, atribuir Nothing a uma variável do tipo define o valor da variável como o valor nulo, não o valor zero do tipo de valor.

Por exemplo:

Dim x As Integer = Nothing
Dim y As Integer? = Nothing

Console.WriteLine(x) ' Prints zero '
Console.WriteLine(y) ' Prints nothing (because the value of y is the null value) '

Observe o CIL gerado (converti ambos para C #):

C #:

private static void Main(string[] args)
{
    decimal? x = null;
    decimal? y = null;
    y = 5M;
    decimal? CS$0$0000 = x;
    decimal? CS$0$0001 = y;
    if ((CS$0$0000.GetValueOrDefault() != CS$0$0001.GetValueOrDefault()) ||
        (CS$0$0000.HasValue != CS$0$0001.HasValue))
    {
        Console.WriteLine("true");
    }
    else
    {
        Console.WriteLine("false");
    }
}

Visual básico:

[STAThread]
public static void Main()
{
    decimal? x = null;
    decimal? y = null;
    y = 5M;
    bool? VB$LW$t_struct$S3 = new bool?(decimal.Compare(x.GetValueOrDefault(), y.GetValueOrDefault()) != 0);
    bool? VB$LW$t_struct$S1 = (x.HasValue & y.HasValue) ? VB$LW$t_struct$S3 : null;
    if (VB$LW$t_struct$S1.GetValueOrDefault())
    {
        Console.WriteLine("true");
    }
    else
    {
        Console.WriteLine("false");
    }
}

Você verá que a comparação no Visual Basic retorna Nullable <bool> (não bool, false ou true!). E indefinido convertido em bool é falso.

Nothingcomparado a tudo o que é sempre Nothing, não falso no Visual Basic (é o mesmo que no SQL).

O problema observado aqui é um caso especial de um problema mais geral, que é que o número de diferentes definições de igualdade que podem ser úteis em pelo menos algumas circunstâncias excede o número de meios comumente disponíveis para expressá-las. Em alguns casos, esse problema é agravado por uma crença infeliz de que é confuso ter diferentes meios de testar a igualdade produzindo resultados diferentes, e tal confusão pode ser evitada fazendo com que as diferentes formas de igualdade produzam os mesmos resultados sempre que possível.

Na realidade, a causa fundamental da confusão é uma crença equivocada de que se deve esperar que as diferentes formas de teste de igualdade e desigualdade produzam o mesmo resultado, não obstante o fato de que semânticas diferentes são úteis em circunstâncias diferentes. Por exemplo, do ponto de vista aritmético, é útil ser capaz de ter Decimalquais diferem apenas no número de zeros à direita comparados como iguais. Da mesma forma para doublevalores como zero positivo e zero negativo. Por outro lado, do ponto de vista de cache ou internamento, essa semântica pode ser mortal. Suponha, por exemplo, que alguém tenha um Dictionary<Decimal, String>tal que myDict[someDecimal]deve ser igual someDecimal.ToString(). Tal objeto pareceria razoável se alguém tivesse muitosDecimalvalores que se deseja converter em string e espera-se que haja muitas duplicatas. Infelizmente, se usado esse cache para converter 12,3 me 12,40 m, seguidos por 12,30 me 12,4 m, os últimos valores renderiam "12,3" e "12,40" em vez de "12,30" e "12,4".

Voltando ao assunto em questão, há mais de uma maneira sensata de comparar objetos anuláveis ​​para igualdade. C # assume o ponto de vista de que seu ==operador deve espelhar o comportamento de Equals. O VB.NET considera que seu comportamento deve espelhar o de algumas outras linguagens, já que quem quiser o Equalscomportamento pode usar Equals. Em certo sentido, a solução certa seria ter uma construção "se" de três vias e exigir que, se a expressão condicional retornar um resultado com três valores, o código deve especificar o que deve acontecer no nullcaso. Já que essa não é uma opção com as línguas como elas são, a próxima melhor alternativa é simplesmente aprender como diferentes línguas funcionam e reconhecer que não são iguais.

A propósito, o operador "Is" do Visual Basic, que está faltando em C, pode ser usado para testar se um objeto anulável é, de fato, nulo. Embora alguém possa questionar se um ifteste deve aceitar um Boolean?, fazer com que os operadores de comparação normais retornem em Boolean?vez de Booleanquando invocados em tipos anuláveis ​​é um recurso útil. A propósito, no VB.NET, se alguém tentar usar o operador de igualdade em vez de Is, obterá um aviso de que o resultado da comparação sempre será Nothing, e deve- Isse usar se quiser testar se algo é nulo.

Pode ser que este post te ajude:

Se bem me lembro, 'Nada' em VB significa "o valor padrão". Para um tipo de valor, esse é o valor padrão, para um tipo de referência, que seria nulo. Portanto, não atribuir nada a uma estrutura não é problema algum.

Esta é uma estranheza definitiva do VB.

No VB, se você deseja comparar dois tipos anuláveis, você deve usar Nullable.Equals().

Em seu exemplo, deveria ser:

Dim x As System.Nullable(Of Decimal) = Nothing
Dim y As System.Nullable(Of Decimal) = Nothing

y = 5
If Not Nullable.Equals(x, y) Then
    Console.WriteLine("true")
Else
    Console.WriteLine("false")
End If

Seu código VB está simplesmente incorreto - se você alterar "x <> y" para "x = y", ainda terá "false" como resultado. A forma mais comum de expressão para instâncias anuláveis ​​é "Not x.Equals (y)", e isso produzirá o mesmo comportamento de "x! = Y" em C #.