web-dev-qa-db-fra.com

Meilleure façon de vérifier la valeur nullable bool dans une expression de condition (si ...)

Je me demandais quelle était la syntaxe la plus propre et la plus compréhensible pour effectuer des contrôles de condition sur des booléens nullables.

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

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

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

(ne sais pas si la question a été posée auparavant ... impossible de trouver quelque chose de similaire avec la recherche)

c#coding-stylenullable
177
FireSnake

Je pense que beaucoup de gens se concentrent sur le fait que cette valeur est annulable, 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

310
Artiom Chilaru

Pourquoi ne pas utiliser GetValueOrDefault , qui s’explique assez bien et permet d’utiliser ce que vous voulez par défaut:

if (nullableBool.GetValueOrDefault(false)) {
}
63
Lucero

Cela ne vous plaît peut-être pas, mais personnellement, je trouve

if (x.HasValue && x.Value)

le plus lisible. Cela indique clairement que vous travaillez avec un type nullable et 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 lit également:

if (x ?? false)

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

39
Dan Diplo

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

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

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
}
8
Andrey Frolov

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
8
user1023602

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) ...
3
Sz. Moncz

En fait, je pense que (nullableBool ?? false) Est une option légitime, en particulier 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 par opposition à:
array.Select(v => v.nullableBool.HasValue ? v.nullableBool.Value : false)
(from v in array where v.nullableBool.HasValue ? v.nullableBool.Value : false)

3
Zze

Si vous voulez seulement tester true contre null/false, je viens de lire et de lire:

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

Je pense que c'est à vous. Je pense certainement que l'approche .HasValue est plus lisible, en particulier pour les développeurs qui ne sont pas familiers avec le ?? syntaxe.

L'autre point d'un type booléen nullable est qu'il s'agit de trois états. Vous souhaiterez peut-être faire autre chose s'il est null, et non par défaut à false.

0
James Westgate

Donné enum

public enum PublishMode { Edit, View }

tu peux le faire comme ici

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

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

Si vous ne pouvez pas contrôler si une partie de la condition vérifie une valeur nullable, vous pouvez toujours essayer les solutions suivantes:

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

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

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

0
MetalPhoenix