comprobar - nullable class c#

La mejor forma de verificar si bool nullable es una expresión de condición(si...)

Question

Me preguntaba cuál era la sintaxis más clara y comprensible para hacer verificaciones de condiciones en bools nullable.

¿El siguiente es un 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 estilo if (x.HasValue && x.Value) ...

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

Answer 1

¿Qué hay de usar GetValueOrDefault , que es bastante autoexplicativo y permite usar el valor predeterminado que desee:

if (nullableBool.GetValueOrDefault(false)) {
}

Answer 2

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 que admite nulos es que es de estado triple, por lo que es posible que desee hacer otra cosa cuando sea simplemente nulo y no predeterminado a falso.

Answer 3

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á a ser verdadero si el bool? es nulo: P

Answer 4

Dado enum

public enum PublishMode { Edit, View }

puedes hacerlo como aquí

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

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

Answer 5

En realidad, creo que (nullableBool ?? false) es una opción legítima, especialmente cuando intentas evaluar un bool nulo 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 que opuesto a:
array.Select(v => v.nullableBool.HasValue ? v.nullableBool.Value : false)
(from v in array where v.nullableBool.HasValue ? v.nullableBool.Value : false)

Answer 6

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 de nullable y deja en claro que primero está comprobando si el tipo que admite nulos tiene un valor antes de actuar de forma condicional.

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

if (x ?? false)

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

Answer 7

Si desea tratar un null como falso, entonces diría que la forma más concisa de hacerlo es usar el operador nulo coalescente ( ?? ), como usted describe:

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

Answer 8

Si se encuentra en una situación en la que no tiene control sobre si parte de la condición está verificando un valor que admite valores NULL, 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 sí resuelve el problema limpiamente.

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

Answer 9

Si solo quiere probar true contra null / false , lo que acabo de usar y leer bastante bien es

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

Answer 10

Solo piensa en bool? como tener 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

Answer 11

Use 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
}

Answer 12

Veamos cómo se define la comparación 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}");
    }

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 de forma segura:

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

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

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