我一直在寻找实际执行重载的 false 运算符的实际工作代码。

This question (What's the false operator in C# good for?)有点相同，但接受的答案链接到返回 404 错误的 url。我也看过 How does operator overloading of true and false work?以及其他一些问题。

我在几乎所有答案中发现的是，false 仅在您使用短路和类似 x && y 时才会执行。这被评估为 T.false(x) ？ x : T.&(x, y).

好的，所以我有以下代码。 struct 包含一个 int 并且如果 int 大于零则认为它自己为真。:

public struct MyStruct {
    private int _i;

    public MyStruct(int i) {
        _i = i;
    }

    public static bool operator true(MyStruct ms) {
        return ms._i > 0;
    }

    public static bool operator false(MyStruct ms) {
        return ms._i <= 0;
    }

    public override string ToString() {
        return this._i.ToString();
    }
}

现在我希望下面的程序将执行并使用重载的 false 运算符。

class Program {
    private static void Main() {
        MyStruct b1 = new MyStruct(1); // to be considered true
        MyStruct b2 = new MyStruct(-1); // to be considered false

        Console.WriteLine(b1 && b2);
        Console.WriteLine(b2 && b1);
    }
}

但是，它甚至无法编译。它说它不能将运算符“&&”应用于“MyStruct”和“MyStruct”类型的操作数。

我知道我可以实现 & 运算符的重载。所以让我们这样做吧。 & 必须返回一个MyStruct，所以我不能让它返回一个bool。

public static MyStruct operator &(MyStruct lhs, MyStruct rhs) {
    return new MyStruct(lhs._i & rhs._i);
}

现在代码可以编译了。它的输出是1和-1。所以b1 && b2的结果和b2 && b1的结果是不一样的。

如果我调试代码，我会看到 b1 && b2 首先在 b1 上执行 false 运算符，它返回 false 。然后它在 b1 和 b2 上执行 & 运算符，它在 1 和 -1 上执行按位与，结果为 1。所以它确实首先检查 b1 是否为假。

第二个表达式，b2 && b1 首先在 b2 上执行 false 运算符，返回 true。结合我使用短路的事实，它不会对 b1 做任何事情，只是打印出 b2 的值。

是的，false 运算符在您使用短路时执行。但是，它不会对第二个参数执行 true 或 false 运算符，而是对操作数执行重载的 & 运算符。

这什么时候有用？或者我如何制作我的类型，以便它可以检查两个变量是否都为真？

最佳答案

您提到的 404 URL 的内容可以在这里找到:

http://web.archive.org/web/20080613013350/http://www.ayende.com/Blog/archive/2006/08/04/7381.aspx

作者所指的文章在这里:

http://web.archive.org/web/20081120013852/http://steve.emxsoftware.com/NET/Overloading+the++and++operators

为避免再次出现同样的问题，这里是文章的重点:

A couple months ago I posted about our query API along with an explanation of how it works. Our query API allows us to express our queries using strongly typed C# syntax:

List<Customer> customers = repository.FindAll(Customer.Columns.Age == 20 & Customer.Columns.Name == “foo”);

One of the things I pointed out in my previous posts was that I couldn’t overload the && and || operators directly since the framework doesn’t allow such craziness…at least not directly.

In particular, it is not possible to overload member access, method invocation, or the =, &&, ||, ?:, checked, unchecked, new, typeof, as, and is operators. http://msdn.microsoft.com/library/default.asp?url=/library/en-us/csspec/html/vclrfcsharpspec_7_2_2.asp

Over the last month I’ve done a little investigation on the topic to see if and how I can get && and || to behave the way I want. This evening I came across the Conditional logical operators page on MSDN which gave me the answer I was looking for:

The operation x && y is evaluated as T.false(x) ? x : T.&(x, y), where T.false(x) is an invocation of the operator false declared in T, and T.&(x, y) is an invocation of the selected operator &. In other words, x is first evaluated and operator false is invoked on the result to determine if x is definitely false. Then, if x is definitely false, the result of the operation is the value previously computed for x. Otherwise, y is evaluated, and the selected operator & is invoked on the value previously computed for x and the value computed for y to produce the result of the operation. The operation x || y is evaluated as T.true(x) ? x : T.|(x, y), where T.true(x) is an invocation of the operator true declared in T, and T.|(x, y) is an invocation of the selected operator |. In other words, x is first evaluated and operator true is invoked on the result to determine if x is definitely true. Then, if x is definitely true, the result of the operation is the value previously computed for x. Otherwise, y is evaluated, and the selected operator | is invoked on the value previously computed for x and the value computed for y to produce the result of the operation. Since we already have the & and | operators in place it was simply a matter of overloading the true and false operators to both return false. This results in the & and | operators always being called which in turn results in the two criteria objects being turned into an AndCriteria/OrCriteria!

So now we can express our criteria expressions using the && and || syntax we’re accustomed to.

repository.FindAll(Customer.Columns.Age == 20 && Customer.Columns.Name == “foo”);

repository.FindAll(Customer.Columns.FirstName == “Foo” || Customer.Columns.LastName == “Bar”);

The relevant operator overloads are shown below.

public static bool operator true(Criteria<T> criteria) {
   return false;
}

public static bool operator false(Criteria<T> criteria) {
   return false;
}

public static Criteria<T> operator &(Criteria<T> lhs, Criteria<T> rhs) {
   return new AndCriteria<T>(lhs, rhs);
}

public static Criteria<T> operator |(Criteria<T> lhs, Criteria<T> rhs) {
   return new OrCriteria<T>(lhs, rhs);
}

关于c# - 重载的 false 运算符什么时候被执行，它有什么用？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/6486300/