检查条件表达式中可为 null 的布尔值的最佳方法（如果 ...）[已结束]

我认为这取决于你。我当然认为.HasValue 方法更具可读性，特别是对于不熟悉 ？？语法。

可为 null 的布尔类型的另一点是它是三态的，因此当它只是 null 而不是默认为 false 时，您可能希望执行其他操作。

你可能不喜欢它，但我个人发现

if (x.HasValue && x.Value)

可读性最强。它清楚地表明您正在使用可为 null 的类型，并清楚地表明您首先检查可为 null 的类型是否具有值，然后再有条件地对它执行操作。

如果你采用你的版本并用 x 替换变量，它也会显示：

if (x ?? false)

有那么清楚吗？很明显 x 是可为 null 的类型吗？我会让你决定的。

如果你想把 a 视为 false，那么我会说最简洁的方法是使用 null 合并运算符 （），如您所述：null??

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

使用扩展。

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
}

如何使用 GetValueOrDefault，这是不言自明的，并允许使用您想要的任何默认值：

if (nullableBool.GetValueOrDefault(false)) {
}

给定枚举

public enum PublishMode { Edit, View }

你可以像这里一样做

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

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

我认为很多人都专注于这个值是可空的，而不考虑他们真正想要的是什么:)

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

或者，如果您想要更多选择...

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

(nullableBool == true)如果布尔值，将永远不会返回 true？为 null :P

如果您无法控制条件的一部分是否正在检查可为 null 值，则始终可以尝试以下操作：

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

我知道这并不完全是一种纯粹的方法，将三元放在 if 语句中，但它确实干净地解决了这个问题。

当然，这是一种手动的说法GetValueOrDefault(false)

让我们检查一下与 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}");
    }

结果是：

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

因此，您可以安全地使用：

// 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 个值，那么事情就变得更容易了：

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

如果你只想测试 / ，我刚刚使用并且读得很好的一个是truenullfalse

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

实际上，我认为这是一个合理的选择，尤其是当您尝试在 linq 中计算可为 null 的布尔值时。(nullableBool ?? false)

例如：

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

在我看来更干净，而不是：

array.Select(v => v.nullableBool.HasValue ? v.nullableBool.Value : false)
(from v in array where v.nullableBool.HasValue ? v.nullableBool.Value : false)

另一种方法是使用常量模式匹配：

if (nullableBool is true) {}
if (nullableBool is false) {}
if (nullableBool is null) {}

与运算符不同，在读取代码时，这将区分可为 null 的类型检查和普通的“带有气味的代码”。==