Meilleure façon de vérifier le booléen nullable dans une expression de condition (si…)

Je me demandais quelle était la syntaxe la plus claire et la plus compréhensible pour faire des vérifications de condition sur les bools nullables.

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

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

en particulier la partie if (nullableBool ?? false) . Je n'aime pas le if (x.HasValue && x.Value)style ...

(Je ne sais pas si la question a déjà été posée ... je n'ai pas trouvé quelque chose de similaire avec la recherche)

Je pense que beaucoup de gens se concentrent sur le fait que cette valeur est nulle, et ne pensent pas à ce qu'ils veulent réellement :)

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 nul: P

Que diriez-vous d'utiliser GetValueOrDefault , qui est assez explicite et permet d'utiliser la valeur par défaut que vous souhaitez:

if (nullableBool.GetValueOrDefault(false)) {
}

Vous ne l'aimez peut-être pas, mais personnellement, je trouve

if (x.HasValue && x.Value)

le plus lisible. Il indique clairement que vous travaillez avec un type nullable et il est clair 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 par x, elle indique également:

if (x ?? false)

Est-ce aussi clair? Est-il évident que x est un type nullable? Je vous laisse décider.

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

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

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

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

Permet de vérifier comment 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

Vous pouvez donc 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) ...

En fait, je pense que (nullableBool ?? false)c'est une option légitime, surtout lorsque vous essayez d'évaluer un bool nullable dans linq.

Par exemple:
array.Select(v => v.nullableBool ?? false)
(from v in array where v.nullableBool ?? false)

Est plus propre à mon avis que:
array.Select(v => v.nullableBool.HasValue ? v.nullableBool.Value : false)
(from v in array where v.nullableBool.HasValue ? v.nullableBool.Value : false)

Si vous voulez seulement tester pour truecontre null/ false, celui que je viens d'utiliser et qui lit assez bien est

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

Je pense que ça dépend de vous. Je pense certainement que l'approche .HasValue est plus lisible, en particulier avec les développeurs qui ne connaissent pas ?? syntaxe.

L'autre point d'un type booléen nullable est qu'il est tristate, donc vous voudrez peut-être faire quelque chose d'autre quand il est juste null, et non par défaut false.

Étant donné l'énumération

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)
       ....
    }

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

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

Je sais que ce n'est pas exactement une approche puriste mettant un ternaire dans une déclaration if, mais cela résout le problème proprement.

C'est, bien sûr, une façon manuelle de dire GetValueOrDefault(false)