創建自定義布爾值？

Question

如何創建bool語法的副本，並且不使用true和false我會使用Enabled和Disabled？我想它要使用像這樣...

sBool E = Enabled; 
sBool f = Disabled; 

if (e || f == Disabled) 
{ 
    Do something... 
} 

Answer 1

只是要一個枚舉這樣

public enum sBool 
{ 
    Enabled, 
    Disabled 
} 

然後你宣佈你的代碼看起來就像這樣：

sBool E = sBool.Enabled; 
sBool f = sBool.Disabled; 

if (E == sBool.Disabled || F == sBool.Disabled) 
{ 
    //Do something... 
} 

編輯：修復if語法

Answer 2

你可以ü瑟枚舉，就像這樣：

enum Status 
{ 
    Enabled, 
    Disabled 
} 

var e = Status.Enabled; 
if (e == Status.Disabled) 
{ 
    // Do something 
} 

我不知道你的使用情況是什麼，但在代碼的可讀性/可維護性方面我會說使用枚舉是最簡單的解決方案，最簡單其他開發商理解。

Answer 3

有沒有一種真正的好方法來做到這一點。 您可以利用這樣的事實，即枚舉實際上只是帶有奇特名稱的整數，並使用按位運算符來模擬邏輯運算符。

所以：

enum Status { Disabled = 0, Enabled = 1 } 

Status a = Status.Disabled; 
Status b = Status.Enabled; 
if((a | b) == Status.Enabled){ 
    //Code 
} 

Answer 4

這是一個小騙子，但你可以在兩個變量這樣的聲明：

Boolean sBool = Enabled; 

：

Boolean Enabled = true; 
Boolean Disabled = false; 

現在你可以在你的代碼編寫缺點：啓用和禁用沒有特殊顏色..

Answer 5

如果sBool起着項目中的顯著作用，您可以選擇實施造成相應的滿量程結構（不枚舉）：

public struct sBool { 
    private Boolean m_Value; 

    public static readonly sBool Enabled = new sBool(true); 
    public static readonly sBool Disabled = new sBool(false); 

    ... 

    private sBool(Boolean value) { 
    m_Value = value; 
    } 

    ... 

    public override bool Equals(object obj) { 
    if (!(obj is sBool)) 
     return false; 

    sBool other = (sBool) obj; 

    return other.m_Value == m_Value; 
    } 

    public override int GetHashCode() { 
    return m_Value ? 1 : 0; 
    } 

    ... 

    public Boolean ToBoolean() { 
    return m_Value; 
    } 

    public static implicit operator Boolean(sBool value) { 
    return value.m_Value; 
    } 
} 

.... 

sBool e = sBool.Enabled; 
sBool f = sBool.Disabled; 

if (e || f == sBool.Disabled) { 
    ... 
} 

Answer 6

我只用一個布爾值，但如果你真的想封裝邏輯在一個單獨的類最可讀的語法可能，你可以做這樣的事情：

public sealed class Status: IEquatable<Status> 
{ 
    public Status(bool isEnabled) 
    { 
     _isEnabled = isEnabled; 
    } 

    public bool IsEnabled 
    { 
     get { return _isEnabled; } 
    } 

    public bool IsDisabled 
    { 
     get { return !_isEnabled; } 
    } 

    public bool Equals(Status other) 
    { 
     return other != null && this.IsEnabled == other.IsEnabled; 
    } 

    public static implicit operator bool(Status status) 
    { 
     return status.IsEnabled; 
    } 

    public static Status Enabled 
    { 
     get { return _enabled; } 
    } 

    public static Status Disabled 
    { 
     get { return _disabled; } 
    } 

    private readonly bool _isEnabled; 

    private static readonly Status _enabled = new Status(true); 
    private static readonly Status _disabled = new Status(false); 
} 

然後爲你的示例代碼，做這樣的事情：

Status e = Status.Enabled; 
Status f = Status.Disabled; 

if (e || f.IsDisabled) 
{ 
    // ... 
} 

// Alternatively: 

if (e.Equals(Status.Enabled) || f.Equals(Status.Disabled)) 
{ 
    // ... 
}