0

如何创建 bool 语法的副本而不使用trueandfalse我会使用Enabledand Disabled？我希望它像这样使用...

sBool E = Enabled;
sBool f = Disabled;

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

6 回答 6

2

这有点作弊，但是您可以像这样声明两个变量：

Boolean Enabled = true;
Boolean Disabled = false;

现在您可以在代码中编写：

Boolean sBool = Enabled;

缺点：Enabled和Disabled没有特殊颜色。

于 2013-08-21T09:41:35.723 回答
2

就这样做一个枚举

public enum sBool 
{
    Enabled,
    Disabled
}

然后您声明您的代码将如下所示：

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

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

编辑：修复了if语法

于 2013-08-21T09:30:02.343 回答
1

您可以使用枚举，如下所示：

enum Status 
{
    Enabled,
    Disabled
}

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

我不确定您的用例是什么，但就代码可读性/可维护性而言，我想说使用枚举是最简单的解决方案，并且其他开发人员最容易理解。

于 2013-08-21T09:30:17.990 回答
1

如果 sBool 在您的项目中扮演重要角色，您可以选择实现相应的全尺寸结构（不是enum）：

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) {
  ...
}
于 2013-08-21T09:45:56.667 回答
0

我只是使用一个布尔值，但如果你真的想用最易读的语法将逻辑封装在一个单独的类中，你可以这样做：

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) )
{
    // ...
}
于 2013-08-21T10:04:59.723 回答
0

确实没有什么好的方法可以做到这一点。您可以利用枚举实际上只是具有花哨名称的整数这一事实，并使用按位运算符来模拟逻辑运算符。

所以：

enum Status { Disabled = 0, Enabled = 1 }

Status a = Status.Disabled;
Status b = Status.Enabled;
if( (a | b) == Status.Enabled){
     //Code
}
于 2013-08-21T09:41:10.963 回答