隐式 (bool) 和 == 运算符覆盖 - 正确处理 if 语句

Question

我有一个自定义类，它同时实现了 == 和 implicit 用于布尔运算符。

这是处理所有可能的正确方法吗，如果 ==/!= 语句并获得预期结果？ 像这样：

public class Foo
{
    public bool Result { get; set; }

    public static bool operator ==(bool @bool, Foo foo)
    {
        return Equals(foo, @bool);
    }
    public static bool operator !=(bool @bool, Foo foo)
    {
        return NotEquals(foo, @bool);
    }
    public static bool operator ==(Foo foo, bool @bool)
    {
        return Equals(foo, @bool);
    }
    public static bool operator !=(Foo foo, bool @bool)
    {
        return NotEquals(foo, @bool);
    }
    public static bool operator ==(Foo foo, Foo fooB)
    {
        return Equals(foo, fooB);
    }
    public static bool operator !=(Foo foo, Foo fooB)
    {
        return NotEquals(foo, fooB);
    }
    public static implicit operator bool(Foo foo)
    {
        try { return foo.Result; }
        catch { return false; }
    }

    private static bool Equals(Foo foo, Foo fooB)
    {
        if (object.Equals(foo, null))
        {
            if (object.Equals(fooB, null))
                return true;

            return false;
        }

        if (object.Equals(fooB, null))
            return false;

        return foo.Result == fooB.Result;
    }
    private static bool NotEquals(Foo foo, Foo fooB)
    {
        if (object.Equals(foo, null))
        {
            if (object.Equals(fooB, null))
                return false;

            return true;
        }

        if (object.Equals(fooB, null))
            return true;

        return fooB.Result != foo.Result;
    }
    private static bool Equals(Foo foo, bool @bool)
    {
        if (object.Equals(foo, null))
            return true;

        return @bool == foo.Result;
    }
    private static bool NotEquals(Foo foo, bool @bool)
    {
        if (object.Equals(foo, null))
            return false;

        return @bool != foo.Result;
    }

}

我特别想知道你似乎真的需要为任何一个实现重载

if (new Foo() != true)

和

if (true != new Foo())

Answer 1

我认为你写了太多代码:-)

以下内容就足够了：

public class Foo
{
    public bool Result { get; set; }

    public static implicit operator bool(Foo foo)
    {
        return !object.ReferenceEquals(foo, null) && foo.Result;
    }
}

然后编译器将知道如何将Foo 类型的变量隐式转换为bool。 （而null 将转换为false）。

所以，当你写的时候：

new Foo() == false

编译器将使用隐式类型转换器从Foo 获取bool 值，然后对bool 使用标准相等运算符。

如果我们查看编译器为该表达式生成的 IL：

newobj instance void FooBool.Foo::.ctor()               // new Foo()
call bool FooBool.Foo::op_Implicit(class FooBool.Foo)   // implicit operator (Foo => bool)
ldc.i4.0                                                // false
ceq                                                     // equality operator (bool)

这是一个测试：

static void Main(string[] args)
{
    AssertTrue(new Foo() == false);
    AssertTrue(false == new Foo());
    AssertFalse(new Foo() != false);
    AssertFalse(false != new Foo());
    AssertTrue(new Foo { Result = true } == true);
    AssertTrue(true == new Foo { Result = true });
    AssertFalse(new Foo { Result = true } != true);
    AssertFalse(true != new Foo { Result = true });
}

static void AssertTrue(bool value)
{
    Console.WriteLine(value ? "ok" : "not ok");
}

static void AssertFalse(bool value)
{
    Console.WriteLine(value ? "not ok" : "ok");
}

它为每个测试打印ok。所以如果我理解正确的话，这个简化的代码应该可以满足你的需求。

更新

要允许等式运算符适用于 Foo（可能为 null）的实例：

public static bool operator ==(Foo a, Foo b)
{
    if (object.ReferenceEquals(a, b))
    {
        return true;
    }
    else if (object.ReferenceEquals(a, null))
    {
        return !b.Result;
    }
    else if (object.ReferenceEquals(b, null))
    {
        return !a.Result;
    }
    else
    {
        return a.Result == b.Result;
    }
}

你还应该实现不等式运算符：

public static bool operator !=(Foo a, Foo b)
{
    return !(a == b);
}

并且还覆盖GetHashCode + Equals

public override int GetHashCode()
{
    return this.Result ? 1 : 0;
}

public override bool Equals(object obj)
{
    if (object.ReferenceEquals(obj, null))
    {
        return !this.Result;
    }

    Type t = obj.GetType();

    if (t == typeof(Foo))
    {
        return this.Result == ((Foo)obj).Result;
    }
    else if (t == typeof(bool))
    {
        return this.Result == (bool)obj;
    }
    else
    {
        return false;
    }
}

Answer 2

我认为您明确涵盖了代码中的所有基础；如果需要，您必须考虑运算符的参数顺序，因此如果您希望为参数的两个顺序调用 Equals 函数，您所做的是正确的。

但是，在比较 Foo 和 bool 的情况下，它看起来有点矫枉过正，因为您可以简单地依赖隐式转换。这将允许您删除这两种类型之间的所有运算符以及 Equals 和 NotEquals 方法。

更重要的是，它可以避免代码中关于将空 Foo 转换为布尔值的一些不一致。当您将空 Foo 传递给 Equals 方法时，它将返回 true 而在隐式转换中，空 Foo 将返回 false：

true == (Foo)null; //true
true == Convert.ToBoolean((Foo)null); //false

---

最后，这是我编写 Foo 类的方法，我认为这就足够了：

public class Foo
{
    public bool Result { get; set; }

    public static bool operator ==(Foo foo, Foo fooB)
    {
        return Equals(foo, fooB);
    }
    public static bool operator !=(Foo foo, Foo fooB)
    {
        return NotEquals(foo, fooB);
    }
    public static implicit operator bool(Foo foo)
    {
        return foo == null ? false : foo.Result;
    }

    private static bool Equals(Foo foo, Foo fooB)
    {
        if (object.Equals(foo, null))
        {
            return object.Equals(fooB, null);
        }

        if (object.Equals(fooB, null))
            return false;

        return foo.Result == fooB.Result;
    }
    private static bool NotEquals(Foo foo, Foo fooB)
    {
        return !Equals(foo, fooB);
    }
}