Der beste Weg, um in einem Bedingungsausdruck nach nullbarem Bool zu suchen (wenn…)

Ich habe mich gefragt, was die sauberste und verständlichste Syntax für die Durchführung von Bedingungsprüfungen für nullfähige Bools ist.

Ist der folgende gute oder schlechte Codierungsstil? Gibt es eine Möglichkeit, den Zustand besser / sauberer auszudrücken?

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

insbesondere der if (nullableBool ?? false) Teil. Ich mag den if (x.HasValue && x.Value)Stil nicht ...

(nicht sicher, ob die Frage schon einmal gestellt wurde ... konnte bei der Suche nichts Ähnliches finden)

Ich denke, viele Leute konzentrieren sich auf die Tatsache, dass dieser Wert nullbar ist, und denken nicht darüber nach, was sie tatsächlich wollen :)

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

Oder wenn Sie mehr Optionen möchten ...

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

(nullableBool == true)wird nie wahr zurückgeben, wenn der Bool? ist null: P.

Wie wäre es mit GetValueOrDefault , das ziemlich selbsterklärend ist und es ermöglicht, jeden gewünschten Standard zu verwenden:

if (nullableBool.GetValueOrDefault(false)) {
}

Sie mögen es vielleicht nicht, aber ich persönlich finde

if (x.HasValue && x.Value)

am besten lesbar. Es macht deutlich, dass Sie mit einem nullbaren Typ arbeiten, und es macht deutlich, dass Sie zuerst prüfen, ob der nullbare Typ einen Wert hat, bevor Sie bedingt darauf reagieren.

Wenn Sie Ihre Version nehmen und die Variable durch x ersetzen, lautet sie auch:

if (x ?? false)

Ist das so klar? Ist es offensichtlich, dass x ein nullbarer Typ ist? Ich werde dich entscheiden lassen.

Wenn Sie a nullals falsch behandeln möchten, würde ich sagen, dass der prägnanteste Weg, dies zu tun, die Verwendung des Null-Koaleszenz-Operators ( ??) ist, wie Sie beschreiben:

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

Denken Sie nur an Bool? Wenn Sie 3 Werte haben, wird es einfacher:

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

Verwenden Sie Erweiterungen.

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
}

Überprüfen wir, wie der Vergleich mit null definiert ist:

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

und die Ergebnisse sind:

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

So können Sie sicher verwenden:

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

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

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

Eigentlich denke ich, dass dies (nullableBool ?? false)eine legitime Option ist, insbesondere wenn Sie versuchen, einen nullbaren Bool in linq auszuwerten.

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

Ist meiner Meinung nach sauberer im Gegensatz zu:
array.Select(v => v.nullableBool.HasValue ? v.nullableBool.Value : false)
(from v in array where v.nullableBool.HasValue ? v.nullableBool.Value : false)

Wenn Sie nur truegegen null/ testen möchten false, ist eine, die ich gerade verwendet habe und die recht gut liest, eine

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

Ich denke, es liegt an dir. Ich denke sicherlich, dass der .HasValue-Ansatz besser lesbar ist, insbesondere bei Entwicklern, die mit dem ?? Syntax.

Der andere Punkt eines nullbaren booleschen Typs ist, dass er tristate ist. Sie möchten also möglicherweise etwas anderes tun, wenn er nur null ist und nicht standardmäßig false.

Enum gegeben

public enum PublishMode { Edit, View }

Sie können es wie hier tun

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

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

Wenn Sie sich in einer Situation befinden, in der Sie keine Kontrolle darüber haben, ob ein Teil der Bedingung einen nullbaren Wert überprüft, können Sie immer Folgendes versuchen:

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

Ich weiß, dass es nicht gerade ein puristischer Ansatz ist, ein Ternär in eine if-Anweisung einzufügen, aber es löst das Problem sauber.

Dies ist natürlich eine manuelle Art zu sagen GetValueOrDefault(false)