Mengapa ada perbedaan dalam memeriksa null terhadap nilai di VB.NET dan C #?

Di VB.NET ini terjadi:

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

Tetapi di C # ini terjadi:

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");
}

Mengapa ada perbedaan?

VB.NET dan C # .NET adalah bahasa yang berbeda, dibuat oleh tim berbeda yang membuat asumsi berbeda tentang penggunaan; dalam hal ini semantik perbandingan NULL.

Preferensi pribadi saya adalah untuk semantik VB.NET, yang pada dasarnya memberi NULL semantik "Saya belum tahu". Kemudian perbandingan 5 dengan "Saya belum tahu". secara alami adalah "Saya belum tahu"; yaitu NULL. Ini memiliki keuntungan tambahan untuk mencerminkan perilaku NULL di (sebagian besar jika tidak semua) database SQL. Ini juga merupakan interpretasi yang lebih standar (daripada C #) dari logika tiga nilai, seperti yang dijelaskan di sini .

Tim C # membuat asumsi berbeda tentang arti NULL, yang mengakibatkan perbedaan perilaku yang Anda tunjukkan. Eric Lippert menulis blog tentang arti NULL dalam C # . Menurut Eric Lippert: "Saya juga menulis tentang semantik nulls di VB / VBScript dan JScript di sini dan di sini ".

Dalam lingkungan apa pun di mana nilai NULL dimungkinkan, penting untuk mengakui bahwa Law of the Excluded Middle (yaitu bahwa A atau ~ A secara tautologis benar) tidak lagi dapat diandalkan.

Memperbarui:

A bool(sebagai lawan a bool?) hanya dapat mengambil nilai TRUE dan FALSE. Namun implementasi bahasa NULL harus memutuskan bagaimana NULL menyebar melalui ekspresi. Dalam VB ekspresi 5=nulldan 5<>nullKEDUA mengembalikan false. Di C #, dari ekspresi yang sebanding 5==nulldan 5!=nullhanya yang kedua pertama [diperbarui 2014-03-02 - PG] mengembalikan false. Namun, di SETIAP lingkungan yang mendukung null, adalah kewajiban programmer untuk mengetahui tabel kebenaran dan propagasi null yang digunakan oleh bahasa tersebut.

Memperbarui

Artikel blog Eric Lippert (disebutkan dalam komentarnya di bawah) tentang semantik sekarang ada di:

• 30 September 2003 - A Whole Lot of Nothing

• 1 Oktober 2003 - A Little More on Nothing

Karena x <> ykembali, Nothingbukan true. Itu tidak didefinisikan karena xtidak didefinisikan. (mirip dengan SQL null).

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

Anda juga harus membandingkan nilai a Nullable(Of Decimal)hanya jika memiliki nilai.

Jadi VB.NET di atas mirip dengan ini (yang terlihat kurang salah):

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

Spesifikasi bahasa VB.NET :

7.1.1 Tipe Nilai Nullable ... Tipe nilai nullable dapat berisi nilai yang sama seperti versi tipe non-nullable serta nilai null. Jadi, untuk tipe nilai nullable, menugaskan Nothing ke variabel tipe menetapkan nilai variabel ke nilai null, bukan nilai nol dari tipe nilai.

Sebagai contoh:

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) '

Lihatlah CIL yang dihasilkan (saya telah mengubah keduanya menjadi 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");
    }
}

Dasar visual:

[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");
    }
}

Anda akan melihat bahwa perbandingan dalam Visual Basic mengembalikan Nullable <bool> (bukan bool, false atau true!). Dan undefined dikonversi ke bool adalah false.

Nothingdibandingkan dengan apa pun yang selalu Nothing, tidak salah dalam Visual Basic (sama seperti di SQL).

Masalah yang diamati di sini adalah kasus khusus dari masalah yang lebih umum, yaitu jumlah definisi berbeda tentang persamaan yang mungkin berguna setidaknya dalam beberapa keadaan melebihi jumlah sarana yang umumnya tersedia untuk mengungkapkannya. Masalah ini dalam beberapa kasus diperburuk oleh keyakinan yang tidak menguntungkan bahwa membingungkan untuk memiliki cara berbeda untuk menguji kesetaraan menghasilkan hasil yang berbeda, dan kebingungan seperti itu dapat dihindari dengan memiliki bentuk persamaan yang berbeda menghasilkan hasil yang sama bila memungkinkan.

Pada kenyataannya, penyebab mendasar dari kebingungan adalah kepercayaan yang salah arah bahwa berbagai bentuk pengujian kesetaraan dan ketidaksetaraan diharapkan dapat memberikan hasil yang sama, terlepas dari kenyataan bahwa semantik yang berbeda berguna dalam keadaan yang berbeda. Misalnya, dari sudut pandang aritmatika, sangat berguna untuk dapat memiliki Decimalyang hanya berbeda dalam jumlah angka nol tertinggal yang dibandingkan sebagai sama. Begitu juga untuk doublenilai seperti nol positif dan nol negatif. Di sisi lain, dari sudut pandang caching atau interning, semantik semacam itu bisa mematikan. Misalkan, misalnya, seseorang memiliki suatu Dictionary<Decimal, String>hal yang myDict[someDecimal]seharusnya samasomeDecimal.ToString() . Objek seperti itu akan tampak masuk akal jika ada banyakDecimalnilai yang ingin diubah menjadi string dan diharapkan ada banyak duplikat. Sayangnya, jika digunakan caching seperti itu untuk mengubah 12,3 m dan 12,40 m, diikuti oleh 12,30 m dan 12,4 m, nilai terakhir akan menghasilkan "12.3", dan "12.4", bukan "12.30" dan "12.4".

Kembali ke masalah yang ada, ada lebih dari satu cara yang masuk akal untuk membandingkan objek nullable untuk persamaan. C # mengambil sudut pandang bahwa ==operatornya harus mencerminkan perilakunya Equals. VB.NET mengambil sudut pandang bahwa perilakunya harus mencerminkan beberapa bahasa lain, karena siapa pun yang menginginkan Equalsperilakunya dapat menggunakan Equals. Dalam beberapa hal, solusi yang tepat adalah memiliki konstruksi "jika" tiga arah, dan mengharuskan jika ekspresi kondisional mengembalikan hasil bernilai tiga, kode harus menentukan apa yang harus terjadi dinull kasus tersebut. Karena itu bukan pilihan untuk bahasa apa adanya, alternatif terbaik berikutnya adalah mempelajari cara kerja bahasa yang berbeda dan mengenali bahwa keduanya tidak sama.

Secara kebetulan, operator "Is" Visual Basic, yang kurang dalam C, dapat digunakan untuk menguji apakah objek nullable, sebenarnya, null. Meskipun orang mungkin secara wajar mempertanyakan apakah suatu ifpengujian harus menerima a Boolean?, meminta operator pembanding normal mengembalikan Boolean?daripada Booleansaat dipanggil pada tipe nullable adalah fitur yang berguna. Kebetulan, di VB.NET, jika seseorang mencoba menggunakan operator persamaan daripada Is, ia akan mendapat peringatan bahwa hasil perbandingan akan selaluNothing , dan seseorang harus menggunakan Isjika ingin menguji apakah ada sesuatu yang nol.

Semoga postingan ini membantu Anda:

Jika saya ingat dengan benar, 'Nothing' dalam VB berarti "nilai default". Untuk tipe nilai, itulah nilai defaultnya, untuk tipe referensi, nilainya null. Jadi, tidak menugaskan apa pun ke struct, tidak masalah sama sekali.

Ini adalah keanehan yang pasti dari VB.

Di VB, jika Anda ingin membandingkan dua tipe nullable, Anda harus menggunakan Nullable.Equals().

Dalam contoh Anda, seharusnya:

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

Kode VB Anda salah - jika Anda mengubah "x <> y" menjadi "x = y", Anda masih akan mendapatkan "false" sebagai hasilnya. Cara paling umum untuk mengungkapkan ini untuk instance nullable adalah "Not x.Equals (y)", dan ini akan menghasilkan perilaku yang sama seperti "x! = Y" di C #.