Beste Weg, um zu überprüfen, für nullable bool in einem Zustand, der Ausdruck (, wenn ...)

Ich Frage mich, was war die saubere und verständliche syntax für tun-Bedingung prüft auf null-Werte zulässt bools.

Wird den folgenden guten oder schlechten coding-Stil? Gibt es eine Möglichkeit, um auszudrücken, die Erkrankung besser/sauberer?

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

besonders die wenn (nullableBool ?? false) Teil. Ich weiß nicht, wie die if (x.HasValue && x.Value) Stil ...

(nicht sicher, ob die Frage gestellt wurde, bevor Sie ... konnte Sie nicht finden, etwas ähnliches mit der Suche)

InformationsquelleAutor der Frage FireSnake | 2010-04-20

c#coding-style nullable

255

Ich denke, dass viele Leute konzentrieren sich auf die Tatsache, dass dieser Wert auf null gesetzt, und nicht darüber nachdenken, was Sie eigentlich wollen 🙂
```
bool? nullableBool = true;
if (nullableBool == true) { ... } //true
else { ... } //false or null
```
Oder wenn Sie wollen, mehr Optionen...
```
bool? nullableBool = true;
if (nullableBool == true) { ... } //true
else if (nullableBool == false) { ... } //false
else { ... } //null
```
(nullableBool == true) wird nie true zurück, wenn der bool? null ist 😛

InformationsquelleAutor der Antwort Artiom Chilaru
53

Wie über die Verwendung GetValueOrDefaultdas ist ziemlich selbsterklärend und ermöglicht es, mit welchem Standard Sie wollen:
```
if (nullableBool.GetValueOrDefault(false)) {
}
```
InformationsquelleAutor der Antwort Lucero
28

Ihnen vielleicht nicht gefällt, aber ich persönlich finde,
```
if (x.HasValue && x.Value)
```
den meisten lesbar. Es macht deutlich, Sie arbeiten mit nullable-Typ, und es macht deutlich, Sie sind zunächst zu überprüfen, ob die nullable-Typ einen Wert hat, bevor Sie auf ihn einwirkenden bedingt.

Wenn Sie Ihre version und ersetzen Sie die variable mit x auch liest:
```
if (x ?? false)
```
Ist das so klar? Ist es offensichtlich x ist ein nullable-Typ? Ich werde Sie entscheiden lassen.

InformationsquelleAutor der Antwort Dan Diplo
17

Wenn Sie möchten, dass zur Behandlung einer null als falsch, dann würde ich sagen, dass die knappste Art und Weise zu tun, ist die Verwendung der null coalesce operator (??), wie Sie es beschreiben:
```
if (nullableBool ?? false) { ... }
```
InformationsquelleAutor der Antwort Oded

Erweiterungen verwenden.

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
}

InformationsquelleAutor der Antwort Andrey Frolov

Denke nur von bool? wie man 3 Werte, dann werden die Dinge einfacher:

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

InformationsquelleAutor der Antwort

Können überprüfen, 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) ...

InformationsquelleAutor der Antwort Sz. Moncz

2

Eigentlich denke ich, dass (nullableBool ?? false) ist eine legitime option, vor allem, wenn Sie versuchen, zu bewerten, nullable bool in linq.

Zum Beispiel:

array.Select(v => v.nullableBool ?? false)

(from v in array where v.nullableBool ?? false)

Reiniger ist meiner Meinung nach 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)

InformationsquelleAutor der Antwort Zze
1

Wenn Sie nur wollen, um zu testen, für true gegen null/falseich habe Sie nur benutzt, und liest sich ganz gut ist
```
bool? someCondition = null
if (someCondition.Equals(true))
...
```
InformationsquelleAutor der Antwort ds4940
0

Ich denke, seine bis zu Ihnen. Ich denke die .HasValue Ansatz ist besser lesbar, vor allem mit den Entwickler nicht kennt????? syntax.

Den anderen Punkt eine null-Typ "boolean" ist, dass es ist tristate, so möchten Sie vielleicht etwas anderes zu tun, wenn es nur null und nicht standardmäßig false.

InformationsquelleAutor der Antwort James Westgate

Gegeben enum

public enum PublishMode { Edit, View }

können Sie es tun, wie hier

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

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

InformationsquelleAutor der Antwort Gopher

0

Wenn Sie in einer situation, wo Sie haben keine Kontrolle darüber, ob ein Teil der Bedingung ist die überprüfung eine null-Wert haben, können Sie immer versuchen Sie Folgendes:
```
if( someInt == 6 && someNullableBool == null ? false : (bool)someNullableBool){
    //perform your actions if true
}
```
Ich weiß es nicht genau einen puristischen Ansatz, indem ein Dreieck in eine if-Anweisung, aber es hat das Problem behoben sauber.

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

InformationsquelleAutor der Antwort MetalPhoenix

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.