Cara terbaik untuk memeriksa bool yang dapat dibatalkan dalam ekspresi kondisi (jika ...)

Saya bertanya-tanya apa sintaks yang paling bersih dan dapat dimengerti untuk melakukan pemeriksaan kondisi pada bools nullable.

Apakah gaya pengkodean baik atau buruk berikut? Apakah ada cara untuk mengekspresikan kondisi lebih baik / lebih bersih?

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

terutama bagian if (nullableBool ?? false) . Saya tidak suka if (x.HasValue && x.Value)gaya ...

(tidak yakin apakah pertanyaan telah diajukan sebelumnya ... tidak dapat menemukan sesuatu yang mirip dengan pencarian)

Saya pikir banyak orang berkonsentrasi pada fakta bahwa nilai ini dapat dibatalkan, dan tidak memikirkan apa yang sebenarnya mereka inginkan :)

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

Atau jika Anda ingin lebih banyak opsi ...

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

(nullableBool == true)tidak akan pernah mengembalikan true jika bool? adalah null: P

Bagaimana dengan menggunakan GetValueOrDefault , yang cukup menjelaskan sendiri dan memungkinkan untuk menggunakan default apa pun yang Anda inginkan:

if (nullableBool.GetValueOrDefault(false)) {
}

Anda mungkin tidak menyukainya, tetapi secara pribadi saya temukan

if (x.HasValue && x.Value)

yang paling mudah dibaca. Itu membuat jelas Anda bekerja dengan tipe nullable dan membuatnya jelas Anda pertama kali memeriksa apakah tipe nullable memiliki nilai sebelum bertindak berdasarkan kondisional.

Jika Anda mengambil versi Anda dan mengganti variabel dengan x juga berbunyi:

if (x ?? false)

Apakah itu jelas? Apakah jelas x adalah tipe yang dapat dibatalkan? Saya akan membiarkan Anda memutuskan.

Jika Anda ingin memperlakukan nullsebagai salah, maka saya akan mengatakan bahwa cara paling ringkas untuk melakukannya adalah dengan menggunakan operator null coalesce ( ??), seperti yang Anda jelaskan:

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

Pikirkan bool saja? memiliki 3 nilai, maka segalanya menjadi lebih mudah:

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

Gunakan ekstensi.

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
}

Mari kita periksa bagaimana perbandingan dengan null didefinisikan:

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

dan hasilnya adalah:

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

Jadi Anda dapat menggunakan:

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

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

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

Sebenarnya saya pikir itu (nullableBool ?? false)adalah pilihan yang sah terutama ketika Anda mencoba untuk mengevaluasi bool nullable di LINQ.

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

Lebih bersih menurut saya dibandingkan dengan:
array.Select(v => v.nullableBool.HasValue ? v.nullableBool.Value : false)
(from v in array where v.nullableBool.HasValue ? v.nullableBool.Value : false)

Jika Anda hanya ingin menguji untuk truemenentang null/ false, Satu saya baru saja menggunakan dan membaca dengan baik adalah

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

Saya pikir itu terserah Anda. Saya tentu berpikir pendekatan .HasValue lebih mudah dibaca, terutama dengan pengembang yang tidak terbiasa dengan ?? sintaksis.

Poin lain dari tipe boolean yang dapat dibatalkan adalah bahwa itu adalah tristate, jadi Anda mungkin ingin melakukan sesuatu yang lain ketika itu hanya nol, dan bukan default ke false.

Diberikan enum

public enum PublishMode { Edit, View }

Anda dapat melakukannya seperti di sini

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

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

Jika Anda berada dalam situasi di mana Anda tidak memiliki kendali atas apakah bagian dari kondisi memeriksa nilai yang dapat dibatalkan, Anda selalu dapat mencoba yang berikut ini:

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

Saya tahu ini bukan pendekatan murni yang menempatkan terner dalam pernyataan if tetapi itu menyelesaikan masalah dengan bersih.

Ini, tentu saja, cara mengatakan secara manual GetValueOrDefault(false)