Hangisi tercih edilir: Boş değer <T> .HasValue veya Boş değer <T>! = Boş?

Her zaman kullandım Nullable<>.HasValueçünkü anlambilimi sevdim. Ancak, son zamanlarda başka birinin mevcut kod tabanı üzerinde çalışıyordum Nullable<> != null.

Birini diğerinin üzerinde kullanmak için bir neden var mı, yoksa sadece tercih mi?

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

vs.

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

Derleyici null karşılaştırmaları çağrıyla değiştirir HasValue, bu yüzden gerçek bir fark yoktur. Siz ve meslektaşlarınız için hangisi daha okunaklı / mantıklı olursa yapın.

(a != null)Sözdiziminin referans türleriyle eşleşmesini tercih ederim .

Nullable int değer atamak için farklı yöntemler kullanarak bu konuda biraz araştırma yaptım. İşte çeşitli şeyler yaptığımda olan şey. Neler olduğunu netleştirmeli. Unutmayın: Nullable<something>ya da steno something?, derleyicinin sanki bir sınıfmış gibi kullanmamıza izin vermek için çok çalıştığı bir yapıdır.
Aşağıda göreceğiniz gibi SomeNullable == nullve SomeNullable.HasValueher zaman doğru veya yanlış beklenen dönecektir. Aşağıda gösterilmemesine rağmen SomeNullable == 3, geçerlidir (SomeNullable'ın bir olduğu varsayılırsa int?).
İken SomeNullable.Valuebize bir çalışma zamanı hatası alır biz atanmış ise nullhiç SomeNullable. Bu, aşırı yüklenmiş operatörlerin, aşırı yüklenmiş bir kombinasyon sayesinde nullablerin bize bir soruna neden olabileceği tek durumdurobject.Equals(obj) yöntemi ve derleyici optimizasyonu ve maymun işi.

İşte çalıştırdığım bazı kodların ve etiketlerde hangi çıktıların üretildiğinin açıklaması:

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.")

Tamam, bir sonraki başlatma yöntemini deneyelim:

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.")

Hepsi eskisi gibi. İle başlatılıyor unutmayın int? val = new int?(null);null nesnenin DEĞER null değil çünkü yapıcısı geçirilen null, bir DERLEME zaman hata oluşturdu olurdu. Null değerine eşit olan yalnızca sarıcı nesnenin kendisidir.

Aynı şekilde, derleme zamanı hatası alırız:

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

val.Valuezaten salt okunur bir özellik olduğundan bahsetmiyorum, yani şöyle bir şey bile kullanamayız:

val.Value = 3;

ancak yine, polimorföz aşırı yüklenmiş örtük dönüşüm operatörleri şunları yapmamıza izin verir:

val = 3;

Doğru çalıştığı sürece polisomthing whatchamacallits hakkında endişelenmenize gerek yok mu? :)

VB.Net'te. ".HasValue" kullanabileceğiniz zaman "IsNot Nothing" kullanmayın. Ben sadece bir "Operasyon çalışma zamanı dengesini bozabilir" Çözüldü "IsNot Nothing" yerine ".HasValue" yerine Orta güven hatası. Nedenini gerçekten anlamıyorum, ancak derleyicide bir şeyler farklı oluyor. C # "! = Null" aynı sorunu olabilir varsayalım.

Linq kullanıyorsanız ve kodunuzu kısa tutmak istiyorsanız, her zaman kullanmanız önerilir !=null

İşte bu yüzden:

Düşünsüz çift değişkenli Foobir sınıfımız olduğunu düşünelimSomeDouble

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

Kodumuzda bir yerde tüm Foo'ları boş olmayan bir SomeDouble değeri olan bir Foo koleksiyonundan (koleksiyondaki bazı foosların da boş olabileceğini varsayarak) almak istiyorsak, fonksiyonumuzu yazmanın en az üç yolunu buluruz (eğer C # 6 kullanın):

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
}

Ve bu tür bir durumda daima daha kısa olanı tercih etmeyi öneririm

Genel cevap ve genel kural: Nullable'ı farklı pipeline'da işlemek objectve belirli özelliklerini kullanmak için bir seçeneğiniz varsa (örneğin özel serileştiriciler yazmak) bunu yapın ve Nullable spesifik özelliklerini kullanın. Dolayısıyla tutarlı düşünme açısından HasValuetercih edilmelidir. Tutarlı düşünme, daha fazla kod yazmanıza yardımcı olabilir, ayrıntılarda çok fazla zaman harcamayın. Örneğin, ikinci yöntem birçok kez daha etkili olacaktır (çoğunlukla derleyiciler inlining ve boks nedeniyle, ancak yine de sayılar çok etkileyici):

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

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

Deney testi:

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 |

Karşılaştırma kodu:

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 kullanıldı

PS . İnsanlar, tavsiyenin "tutarlı düşünme nedeniyle HasValue'yu tercih ettiğini" ilgili ve işe yaramaz olduğunu söylüyor. Bunun performansını tahmin edebilir misiniz?

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

PPS İnsanlar eksi devam ediyor ama kimse performansını tahmin etmeye çalışmıyor CheckNullableGenericImpl. Ve orada derleyici değiştirmekte yardımcı olmayacaktır !=nullile HasValue. HasValueperformansla ilgileniyorsanız doğrudan kullanılmalıdır.