Il modo migliore per verificare la presenza di valori boollegabili nulla in un'espressione condizione (se ...)

Mi chiedevo quale fosse la sintassi più pulita e comprensibile per fare i controlli delle condizioni sui bool di nullable.

Il seguente stile di codifica è buono o cattivo? C'è un modo per esprimere la condizione in modo migliore / più pulito?

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

in particolare la parte if (nullableBool ?? false) . Non mi piace lo if (x.HasValue && x.Value)stile ...

(non sono sicuro se la domanda sia stata posta prima ... non è stato possibile trovare qualcosa di simile con la ricerca)

Penso che molte persone si concentrino sul fatto che questo valore è nullable e non pensano a ciò che vogliono effettivamente :)

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

O se vuoi più opzioni ...

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

(nullableBool == true)non tornerà mai vero se il bool? è null: P

Che ne dici di usare GetValueOrDefault , che è piuttosto autoesplicativo e ti permette di usare qualunque impostazione predefinita tu voglia:

if (nullableBool.GetValueOrDefault(false)) {
}

Potrebbe non piacerti, ma personalmente lo trovo

if (x.HasValue && x.Value)

il più leggibile. Indica chiaramente che stai lavorando con un tipo nullable e chiarisce che stai prima verificando se il tipo nullable ha un valore prima di agire in modo condizionale.

Se prendi la tua versione e sostituisci la variabile con x, si legge anche:

if (x ?? false)

È chiaro? È ovvio x è un tipo nullable? Ti lascio decidere.

Se vuoi trattare un nullcome falso, direi che il modo più succinto per farlo è usare l'operatore null coalesce ( ??), come descrivi:

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

Pensi solo a bool? come avere 3 valori, quindi le cose diventano più facili:

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

Usa le estensioni.

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
}

Consente di verificare come viene definito il confronto con 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}");
    }

e i risultati sono:

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

Quindi puoi usare in sicurezza:

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

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

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

In realtà penso che (nullableBool ?? false)sia un'opzione legittima soprattutto quando stai cercando di valutare un bool nulla in Linq.

Per esempio:
array.Select(v => v.nullableBool ?? false)
(from v in array where v.nullableBool ?? false)

Secondo me è più pulito rispetto a:
array.Select(v => v.nullableBool.HasValue ? v.nullableBool.Value : false)
(from v in array where v.nullableBool.HasValue ? v.nullableBool.Value : false)

Se vuoi solo provare truecontro null/ false, quello che ho appena usato e che legge abbastanza bene lo è

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

Penso che dipenda da te. Penso certamente che l'approccio .HasValue sia più leggibile, specialmente con gli sviluppatori che non hanno familiarità con ?? sintassi.

L'altro punto di un tipo booleano nullable è che è tristato, quindi potresti voler fare qualcos'altro quando è solo null, e non predefinito su false.

Dato enum

public enum PublishMode { Edit, View }

puoi farlo come qui

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

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

Se ti trovi in ​​una situazione in cui non hai il controllo sul fatto che parte della condizione stia verificando un valore nullable, puoi sempre provare quanto segue:

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

So che non è esattamente un approccio purista che inserisce un ternario in un'istruzione if, ma risolve il problema in modo chiaro.

Questo è, ovviamente, un modo di dire manuale GetValueOrDefault(false)