La mejor manera de verificar si hay bool anulable en una expresión de condición (si ...)

Me preguntaba cuál era la sintaxis más limpia y comprensible para hacer verificaciones de condición en las boletas anulables.

¿Es el siguiente estilo de codificación bueno o malo? ¿Hay alguna manera de expresar la condición mejor / más limpiamente?

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

especialmente la parte if (nullableBool ?? false) . No me gusta el if (x.HasValue && x.Value)estilo ...

(no estoy seguro si la pregunta se ha hecho antes ... no se pudo encontrar algo similar con la búsqueda)

Creo que muchas personas se concentran en el hecho de que este valor es anulable, y no piensan en lo que realmente quieren :)

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

O si quieres más opciones ...

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

(nullableBool == true)nunca volverá cierto si el bool? es nulo: P

¿Qué tal usar GetValueOrDefault , que se explica por sí solo y permite usar el valor predeterminado que desee?

if (nullableBool.GetValueOrDefault(false)) {
}

Puede que no te guste, pero personalmente encuentro

if (x.HasValue && x.Value)

El más legible. Deja en claro que está trabajando con un tipo anulable y deja en claro que primero está verificando si el tipo anulable tiene un valor antes de actuar condicionalmente.

Si toma su versión y reemplaza la variable con x también se lee:

if (x ?? false)

¿Está eso tan claro? ¿Es obvio que x es un tipo anulable? Te dejaré decidir.

Si desea tratar un nullcomo falso, entonces diría que la forma más sucinta de hacerlo es usar el operador de fusión nula ( ??), como usted describe:

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

Solo piensa en bool? teniendo 3 valores, entonces las cosas se vuelven más fáciles:

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

Usa extensiones.

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
}

Veamos cómo se define la comparación con nulo:

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

y los resultados son:

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

Para que pueda usar con seguridad:

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

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

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

En realidad, creo que (nullableBool ?? false)es una opción legítima, especialmente cuando intentas evaluar un bool anulable en linq.

Por ejemplo:
array.Select(v => v.nullableBool ?? false)
(from v in array where v.nullableBool ?? false)

Es más limpio en mi opinión en lugar de:
array.Select(v => v.nullableBool.HasValue ? v.nullableBool.Value : false)
(from v in array where v.nullableBool.HasValue ? v.nullableBool.Value : false)

Si solo quieres probar truecontra null/ false, uno que acabo de usar y lee bastante bien es

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

Creo que depende de ti. Ciertamente creo que el enfoque .HasValue es más legible, especialmente con los desarrolladores que no están familiarizados con el ?? sintaxis.

El otro punto de un tipo booleano anulable es que es triestado, por lo que es posible que desee hacer algo más cuando es simplemente nulo y no predeterminado a falso.

Enum dado

public enum PublishMode { Edit, View }

puedes hacerlo como aquí

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

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

Si se encuentra en una situación en la que no tiene control sobre si parte de la condición está verificando un valor anulable, siempre puede intentar lo siguiente:

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

Sé que no es exactamente un enfoque purista poner un ternario en una declaración if, pero resuelve el problema limpiamente.

Esta es, por supuesto, una forma manual de decir GetValueOrDefault(false)