Najlepszy sposób na sprawdzenie wartości zerowej bool w wyrażeniu warunkowym (jeśli…)

Zastanawiałem się, jaka była najbardziej czysta i zrozumiała składnia do sprawdzania warunków na zerowalnych wartościach logicznych.

Czy następujący dobry lub zły styl kodowania? Czy istnieje sposób, aby lepiej / bardziej wyrazić ten stan?

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

szczególnie część if (nullableBool ?? false) . Nie podoba mi się if (x.HasValue && x.Value)styl ...

(nie jestem pewien, czy pytanie zostało zadane wcześniej ... nie można znaleźć czegoś podobnego przy wyszukiwaniu)

Myślę, że wiele osób koncentruje się na tym, że ta wartość jest zerowa, i nie myślą o tym, czego naprawdę chcą :)

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

Lub jeśli chcesz więcej opcji ...

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

(nullableBool == true)nigdy nie zwróci prawdy, jeśli bool? jest zerowy: P

Co powiesz na użycie GetValueOrDefault , która jest dość intuicyjna i pozwala na użycie dowolnej domyślnej wartości:

if (nullableBool.GetValueOrDefault(false)) {
}

Może ci się to nie podobać, ale osobiście uważam

if (x.HasValue && x.Value)

najbardziej czytelny. Wyjaśnia, że ​​pracujesz z typem zerowalnym i wyjaśnia, że ​​najpierw sprawdzasz, czy typ zerowalny ma wartość, zanim zaczniesz działać na nim warunkowo.

Jeśli weźmiesz swoją wersję i zamienisz zmienną na x, to będzie ona brzmiała:

if (x ?? false)

Czy to tak jasne? Czy to oczywiste, że x jest typem zerowalnym? Pozwolę ci zdecydować.

Jeśli chcesz traktować nulljako fałsz, powiedziałbym, że najbardziej zwięzłym sposobem na to jest użycie operatora zerowej koalescencji ( ??), jak to opisano:

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

Pomyśl o bool? ponieważ mają 3 wartości, to staje się łatwiejsze:

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

Użyj rozszerzeń.

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
}

Pozwala sprawdzić, jak zdefiniowane jest porównanie z wartością null:

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

a wyniki to:

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

Możesz więc bezpiecznie używać:

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

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

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

Właściwie uważam, że (nullableBool ?? false)jest to uzasadniona opcja, zwłaszcza gdy próbujesz ocenić zerowalne bool w linq.

Na przykład:
array.Select(v => v.nullableBool ?? false)
(from v in array where v.nullableBool ?? false)

Moim zdaniem jest czystszy w przeciwieństwie do:
array.Select(v => v.nullableBool.HasValue ? v.nullableBool.Value : false)
(from v in array where v.nullableBool.HasValue ? v.nullableBool.Value : false)

Jeśli chcesz testować tylko trueprzeciwko null/ false, jest to jeden, którego właśnie użyłem i czyta całkiem dobrze

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

Myślę, że to zależy od ciebie. Z pewnością uważam, że podejście .HasValue jest bardziej czytelne, szczególnie w przypadku programistów nie znających ?? składnia.

Innym punktem zerowalnego typu logicznego jest to, że jest to tristate, więc możesz chcieć zrobić coś innego, gdy jest on po prostu zerowy, a domyślnie nie ma wartości false.

Biorąc pod uwagę wyliczenie

public enum PublishMode { Edit, View }

możesz to zrobić tak jak tutaj

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

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

Jeśli znajdujesz się w sytuacji, w której nie masz kontroli nad tym, czy część warunku sprawdza wartość zerowalną, zawsze możesz wypróbować następujące czynności:

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

Wiem, że to nie jest dokładnie purystyczne podejście do umieszczenia trójki w instrukcji if, ale rozwiązuje problem w czysty sposób.

Jest to oczywiście ręczny sposób powiedzenia GetValueOrDefault(false)