Bir koşul ifadesinde null olabilecek boolü kontrol etmenin en iyi yolu (eğer…)

Nullable bools üzerinde durum kontrolleri yapmak için en temiz ve anlaşılır sözdiziminin ne olduğunu merak ediyordum.

Aşağıdaki iyi veya kötü kodlama tarzı mı? Durumu daha iyi / daha temiz bir şekilde ifade etmenin bir yolu var mı?

bool? nullableBool = true;
if (nullableBool ?? false) { ... }
else { ... }

özellikle if (nullableBool ?? false) kısmı. Tarzdan hoşlanmıyorum if (x.HasValue && x.Value)...

(sorunun daha önce sorulup sorulmadığından emin değilim ... arama ile benzer bir şey bulamadık)

Birçok insanın bu değerin null edilebilir olduğu gerçeğine odaklandığını ve aslında ne istediklerini düşünmediğini düşünüyorum :)

bool? nullableBool = true;
if (nullableBool == true) { ... } // true
else { ... } // false or null

Veya daha fazla seçenek istiyorsanız ...

bool? nullableBool = true;
if (nullableBool == true) { ... } // true
else if (nullableBool == false) { ... } // false
else { ... } // null

(nullableBool == true)bool ise asla doğru dönmeyecek? boş: P

Kendini açıklayan ve istediğiniz varsayılanı kullanmanıza izin veren GetValueOrDefault'u kullanmaya ne dersiniz :

if (nullableBool.GetValueOrDefault(false)) {
}

Hoşuna gitmeyebilir, ama şahsen buluyorum

if (x.HasValue && x.Value)

en okunabilir. Null olabilecek bir türle çalıştığınızı açıkça belirtir ve null edilebilir türün koşullu olarak işlem yapmadan önce bir değere sahip olup olmadığını kontrol ettiğinizi açıkça belirtir.

Sürümünüzü alıp değişkeni x ile değiştirirseniz:

if (x ?? false)

Bu açık mı? X'in boş değerli bir tür olduğu aşikar mı? Karar vermene izin vereceğim.

Eğer bir nullyanlış gibi davranmak istiyorsanız , o zaman bunu yapmanın en kısa yolunun ??tanımladığınız gibi boş birleşme operatörünü ( ) kullanmak olduğunu söyleyebilirim :

if (nullableBool ?? false) { ... }

Sadece bool'u mu düşünüyorsun? 3 değeri olduğu için işler kolaylaşır:

if (someNullableBool == true)     // only if true
if (someNullableBool == false)    // only if false
if (someNullableBool == null)     // only if null

Uzantıları kullanın.

public static class NullableMixin {
    public static bool IsTrue(this System.Nullable<bool> val) {
        return val == true;
    }
    public static bool IsFalse(this System.Nullable<bool> val) {
        return val == false;
    }
    public static bool IsNull(this System.Nullable<bool> val) {
        return val == null;
    }
    public static bool IsNotNull(this System.Nullable<bool> val) {
        return val.HasValue;
    }
}


Nullable<bool> value = null;
if(value.IsTrue()) {
// do something with it
}

Null ile karşılaştırmanın nasıl tanımlandığını kontrol edelim:

static void Main()
    {
        Console.WriteLine($"null != null  => {null != null}");
        Console.WriteLine($"null == null  => {null == null}");
        Console.WriteLine($"null != true  => {null != true}");
        Console.WriteLine($"null == true  => {null == true}");
        Console.WriteLine($"null != false => {null != false}");
        Console.WriteLine($"null == false => {null == false}");
    }

ve sonuçlar:

null != null  => False                                                                                                                                                                                                                                  
null == null  => True                                                                                                                                                                                                                                   
null != true  => True                                                                                                                                                                                                                                   
null == true  => False                                                                                                                                                                                                                                  
null != false => True                                                                                                                                                                                                                                   
null == false => False

Böylece güvenle kullanabilirsiniz:

// check if null or false
if (nullable != true) ...

// check if null or true
if (nullable != false) ...

// check if true or false
if (nullable != null) ...

Aslında bu (nullableBool ?? false)özellikle linq içinde bir boş boole değerlendirmek için çalışırken meşru bir seçenek olduğunu düşünüyorum .

Örneğin:
array.Select(v => v.nullableBool ?? false)
(from v in array where v.nullableBool ?? false)

Bence aksine daha temiz:
array.Select(v => v.nullableBool.HasValue ? v.nullableBool.Value : false)
(from v in array where v.nullableBool.HasValue ? v.nullableBool.Value : false)

Eğer sadece teste istiyorsanız truekarşı da null/ falseOne Sadece kullanılan ve oldukça iyi okur olduğunu ettik

bool? someCondition = null
if (someCondition.Equals(true))
...

Sanırım bu size bağlı. Kesinlikle .HasValue yaklaşımı, özellikle aşina olmayan geliştiriciler ile daha okunabilir olduğunu düşünüyorum ?? sözdizimi.

Null olabilecek bir boole türünün diğer noktası, tristat olmasıdır, bu nedenle sadece null olduğunda ve varsayılanı false olarak değilken başka bir şey yapmak isteyebilirsiniz.

Enum verildi

public enum PublishMode { Edit, View }

burada olduğu gibi yapabilirsin

 void MyMethod(PublishMode? mode)
    {
       var publishMode = mode ?? PublishMode.Edit;

//or
       if (mode?? PublishMode.Edit == someValue)
       ....
    }

Koşulun bir kısmının boş değerli bir değeri kontrol edip etmediğini kontrol edemediğiniz bir durumdaysanız, her zaman aşağıdakileri deneyebilirsiniz:

if( someInt == 6 && someNullableBool == null ? false : (bool)someNullableBool){
    //perform your actions if true
}

Üçlü bir if deyimine koyarak saf bir yaklaşım olmadığını biliyorum ama sorunu temiz bir şekilde çözüyor.

Tabii ki bu el ile söylemenin bir yolu GetValueOrDefault(false)