Meilleure façon de vérifier la présence d'une valeur booléenne nulle dans une expression de condition (si ...)

Question

Je me demandais quelle était la syntaxe la plus propre et la plus compréhensible pour effectuer des vérifications de condition sur les booléens Nullable.

Le style de codage est-il bon ou mauvais? Existe-t-il un moyen d'exprimer la condition mieux/plus proprement?

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

surtout si (?? nullableBool false) partie. Je n'aime pas le style if (x.HasValue && x.Value) ...

(pas sûr que la question a été posée ... n'a pas pu trouver quelque chose de similaire avec la recherche)

Answer 1

Je pense que beaucoup de gens se concentrent sur le fait que cette valeur est annulable, et ne pense pas à ce qu'ils veulent vraiment :)

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

Ou si vous voulez plus d'options ...

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

(nullableBool == true) ne reviendra jamais vrai si le bool?est nulle: P

Answer 2

Je pense que jusqu'à vous . Je pense certainement que l'approche .HasValue est plus lisible, surtout avec les développeurs qui ne connaissent pas le ?? syntaxe.

L'autre point d'un type booléen Nullable est qu'il est tristate, donc vous pouvez vouloir faire autre chose quand il est juste null, et non par défaut à false.

Answer 3

Vous ne pouvez pas l'aimer, mais personnellement je trouve

if (x.HasValue && x.Value) 

le plus lisible. Il indique clairement que vous travaillez avec un type Nullable et indique clairement que vous vérifiez d'abord si le type Nullable a une valeur avant d'agir de manière conditionnelle.

Si vous prenez votre version et remplacez la variable avec x aussi lit comme suit:

if (x ?? false) 

Est-ce aussi clair? Est-ce évident que x est un type nullable? Je vais te laisser décider.

Answer 4

Si vous voulez traiter un null comme faux, je dirais que la façon la plus succincte de le faire est d'utiliser l'opérateur coalesce null (??), que vous décrivez:

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

Answer 5

Utiliser des extensions .

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 6

Comment l'utilisation GetValueOrDefault, ce qui est assez auto-expliquer et permet d'utiliser tous les défaut que vous voulez:

if (nullableBool.GetValueOrDefault(false)) { 
} 

Answer 7

Compte tenu ENUM

public enum PublishMode { Edit, View } 

vous pouvez le faire comme ici

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

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

Answer 8

Si vous êtes dans une situation où vous ne contrôlez si une partie de la condition vérifie une valeur nulle, vous pouvez toujours essayer ce qui suit:

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

Je sais ce n'est pas exactement une approche puriste qui met un ternaire dans une instruction if mais qui résout le problème proprement.

Ceci est, bien sûr, d'une manière manuelle de dire GetValueOrDefault(false)

Answer 9

permet de vérifier la façon dont la comparaison avec NULL est définie:

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

et les résultats sont:

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

Alors vous pouvez utiliser en toute sécurité:

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

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

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

Answer 10

Pensez juste à bool? comme ayant 3 valeurs, alors les choses deviennent plus faciles:

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

Answer 11

Si vous voulez seulement tester true contre null/false, celui que je viens d'utiliser et lit très bien est

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