Mana yang lebih disukai: Nullable <T> .HasValue atau Nullable <T>! = Null?

Saya selalu menggunakan Nullable<>.HasValuekarena saya menyukai semantik. Namun, baru-baru ini saya sedang mengerjakan basis kode orang lain yang sudah ada di mana mereka menggunakannya Nullable<> != nullsecara eksklusif.

Apakah ada alasan untuk menggunakan salah satu dari yang lain, atau itu murni preferensi?

1. int? a;
   if (a.HasValue)
       // ...

vs.

2. int? b;
   if (b != null)
       // ...

Kompiler menggantikan perbandingan nol dengan panggilan ke HasValue, jadi tidak ada perbedaan nyata. Lakukan saja yang lebih mudah dibaca / lebih masuk akal bagi Anda dan kolega Anda.

Saya lebih suka (a != null)agar sintaks cocok dengan jenis referensi.

Saya melakukan riset tentang hal ini dengan menggunakan metode yang berbeda untuk menetapkan nilai ke int nullable. Inilah yang terjadi ketika saya melakukan berbagai hal. Harus menjelaskan apa yang terjadi. Perlu diingat: Nullable<something>atau steno something?adalah struct yang tampaknya dikompilasi oleh banyak kompiler agar kita gunakan dengan null seolah-olah itu adalah kelas.
Seperti yang akan Anda lihat di bawah, SomeNullable == nulldan SomeNullable.HasValueakan selalu mengembalikan yang diharapkan benar atau salah. Meskipun tidak diperlihatkan di bawah, SomeNullable == 3valid juga (dengan asumsi SomeNullable adalah an int?).
Sementara SomeNullable.Valuemembuat kita error jika kita ditugaskan nulluntuk SomeNullable. Ini sebenarnya satu-satunya kasus di mana nullables dapat menyebabkan masalah bagi kami, berkat kombinasi operator yang kelebihan beban, kelebihan muatanobject.Equals(obj) metode, dan optimisasi kompiler dan bisnis monyet.

Berikut ini adalah deskripsi dari beberapa kode yang saya jalankan, dan output apa yang dihasilkan oleh label:

int? val = null;
lbl_Val.Text = val.ToString(); //Produced an empty string.
lbl_ValVal.Text = val.Value.ToString(); //Produced a runtime error. ("Nullable object must have a value.")
lbl_ValEqNull.Text = (val == null).ToString(); //Produced "True" (without the quotes)
lbl_ValNEqNull.Text = (val != null).ToString(); //Produced "False"
lbl_ValHasVal.Text = val.HasValue.ToString(); //Produced "False"
lbl_NValHasVal.Text = (!(val.HasValue)).ToString(); //Produced "True"
lbl_ValValEqNull.Text = (val.Value == null).ToString(); //Produced a runtime error. ("Nullable object must have a value.")
lbl_ValValNEqNull.Text = (val.Value != null).ToString(); //Produced a runtime error. ("Nullable object must have a value.")

Oke, mari kita coba metode inisialisasi selanjutnya:

int? val = new int?();
lbl_Val.Text = val.ToString(); //Produced an empty string.
lbl_ValVal.Text = val.Value.ToString(); //Produced a runtime error. ("Nullable object must have a value.")
lbl_ValEqNull.Text = (val == null).ToString(); //Produced "True" (without the quotes)
lbl_ValNEqNull.Text = (val != null).ToString(); //Produced "False"
lbl_ValHasVal.Text = val.HasValue.ToString(); //Produced "False"
lbl_NValHasVal.Text = (!(val.HasValue)).ToString(); //Produced "True"
lbl_ValValEqNull.Text = (val.Value == null).ToString(); //Produced a runtime error. ("Nullable object must have a value.")
lbl_ValValNEqNull.Text = (val.Value != null).ToString(); //Produced a runtime error. ("Nullable object must have a value.")

Semua sama seperti sebelumnya. Perlu diingat bahwa menginisialisasi dengan int? val = new int?(null);, dengan null yang diteruskan ke konstruktor, akan menghasilkan kesalahan waktu COMPILE, karena VALUE objek yang dapat dibatalkan TIDAK BISA nullable. Hanya objek pembungkus itu sendiri yang bisa sama dengan nol.

Demikian juga, kami akan mendapatkan kesalahan waktu kompilasi dari:

int? val = new int?();
val.Value = null;

belum lagi itu val.Valueadalah properti baca-saja, artinya kita bahkan tidak bisa menggunakan sesuatu seperti:

val.Value = 3;

tetapi sekali lagi, operator konversi implisit berlebih polimorf mari kita lakukan:

val = 3;

Tidak perlu khawatir tentang polisom apa pun yang bisa menahan, asalkan berfungsi dengan benar? :)

Di VB.Net. JANGAN gunakan "IsNot Nothing" saat Anda dapat menggunakan ".HasValue". Saya baru saja memecahkan "Operasi dapat membuat kestabilan runtime" kesalahan trust Sedang dengan mengganti "IsNot Nothing" dengan ".HasValue" Di satu tempat. Saya tidak begitu mengerti mengapa, tetapi ada sesuatu yang terjadi secara berbeda di kompiler. Saya akan berasumsi bahwa "! = Null" di C # mungkin memiliki masalah yang sama.

Jika Anda menggunakan LINQ dan ingin menjaga kode Anda pendek, saya sarankan untuk selalu menggunakan !=null

Dan inilah sebabnya:

Bayangkan kita memiliki beberapa kelas Foodengan variabel ganda nullableSomeDouble

public class Foo
{
    public double? SomeDouble;
    //some other properties
}   

Jika di suatu tempat dalam kode kita, kita ingin mendapatkan semua Foo dengan nilai SomeDouble non null dari koleksi Foo (dengan asumsi beberapa foo dalam koleksi bisa juga nol), kita berakhir dengan setidaknya tiga cara untuk menulis fungsi kita (jika kita gunakan C # 6):

public IEnumerable<Foo> GetNonNullFoosWithSomeDoubleValues(IEnumerable<Foo> foos)
{
     return foos.Where(foo => foo?.SomeDouble != null);
     return foos.Where(foo=>foo?.SomeDouble.HasValue); // compile time error
     return foos.Where(foo=>foo?.SomeDouble.HasValue == true); 
     return foos.Where(foo=>foo != null && foo.SomeDouble.HasValue); //if we don't use C#6
}

Dan dalam situasi seperti ini saya sarankan untuk selalu mencari yang lebih pendek

Jawaban umum dan aturan praktis: jika Anda memiliki pilihan (misalnya menulis serializers khusus) untuk memproses Nullable dalam pipa yang berbeda dari object- dan menggunakan properti spesifik mereka - lakukan dan gunakan properti spesifik Nullable. Jadi dari sudut pandang pemikiran yang konsisten HasValueharus lebih disukai. Pemikiran yang konsisten dapat membantu Anda menulis kode yang lebih baik agar tidak menghabiskan terlalu banyak waktu dalam perincian. Misalnya ada metode kedua akan berkali-kali lebih efektif (kebanyakan karena kompiler inlining dan tinju tetapi angka masih sangat ekspresif):

public static bool CheckObjectImpl(object o)
{
    return o != null;
}

public static bool CheckNullableImpl<T>(T? o) where T: struct
{
    return o.HasValue;
}

Tes patokan:

BenchmarkDotNet=v0.10.5, OS=Windows 10.0.14393
Processor=Intel Core i5-2500K CPU 3.30GHz (Sandy Bridge), ProcessorCount=4
Frequency=3233539 Hz, Resolution=309.2587 ns, Timer=TSC
  [Host] : Clr 4.0.30319.42000, 64bit RyuJIT-v4.6.1648.0
  Clr    : Clr 4.0.30319.42000, 64bit RyuJIT-v4.6.1648.0
  Core   : .NET Core 4.6.25009.03, 64bit RyuJIT


        Method |  Job | Runtime |       Mean |     Error |    StdDev |        Min |        Max |     Median | Rank |  Gen 0 | Allocated |
-------------- |----- |-------- |-----------:|----------:|----------:|-----------:|-----------:|-----------:|-----:|-------:|----------:|
   CheckObject |  Clr |     Clr | 80.6416 ns | 1.1983 ns | 1.0622 ns | 79.5528 ns | 83.0417 ns | 80.1797 ns |    3 | 0.0060 |      24 B |
 CheckNullable |  Clr |     Clr |  0.0029 ns | 0.0088 ns | 0.0082 ns |  0.0000 ns |  0.0315 ns |  0.0000 ns |    1 |      - |       0 B |
   CheckObject | Core |    Core | 77.2614 ns | 0.5703 ns | 0.4763 ns | 76.4205 ns | 77.9400 ns | 77.3586 ns |    2 | 0.0060 |      24 B |
 CheckNullable | Core |    Core |  0.0007 ns | 0.0021 ns | 0.0016 ns |  0.0000 ns |  0.0054 ns |  0.0000 ns |    1 |      - |       0 B |

Kode benchmark:

public class BenchmarkNullableCheck
{
    static int? x = (new Random()).Next();

    public static bool CheckObjectImpl(object o)
    {
        return o != null;
    }

    public static bool CheckNullableImpl<T>(T? o) where T: struct
    {
        return o.HasValue;
    }

    [Benchmark]
    public bool CheckObject()
    {
        return CheckObjectImpl(x);
    }

    [Benchmark]
    public bool CheckNullable()
    {
        return CheckNullableImpl(x);
    }
}

https://github.com/dotnet/BenchmarkDotNet digunakan

PS . Orang mengatakan bahwa saran "lebih memilih HasValue karena pemikiran yang konsisten" tidak berhubungan dan tidak berguna.Bisakah Anda memprediksi kinerja ini?

public static bool CheckNullableGenericImpl<T>(T? t) where T: struct
{
    return t != null; // or t.HasValue?
}

Orang-orang PPS terus minus tetapi tidak ada yang mencoba memprediksi kinerja CheckNullableGenericImpl. Dan ada compiler tidak akan membantu Anda mengganti !=nulldengan HasValue. HasValueharus digunakan secara langsung jika Anda tertarik dengan kinerja.