如何使乘法运算符(*)表现为短路？

Question

我有很多计算,特别是乘法,其中第一部分有时为零,在这种情况下我不想评估第二个操作数.C#中至少有两个短路运算符:&&并且||仅在必要时才评估第二个操作数.我想用乘法运算符实现类似的行为.

在.net中,您不能&&直接重载操作符,但您可以重载&和false操作符,这样您就可以使用扩展点来改变短路操作符的行为.您可以在本文中找到更多详细信息C#运算符重载:'&&'运算符

是否有任何方法可以实现乘法运算符的这种或类似的行为？

这是一个纯语法问题,因为实现非常简单.下一个方法在功能方面完全符合我的要求:

public static double ShortCircuitMultiply(double val, Func<double> anotherValue)
{
    var epsilon = 0.00000001;
    return Math.Abs(val) < epsilon ? 0 : val * anotherValue();
}

注:此实现不充分:在C#中,如果你乘0.0用 Double.NaN 或者Double.NegativeInfinity或者Double.PositiveInfinity,你会得到NaN,但在以下方面ShortCircuitMultiply-只有零.让我们忽略这个细节,它在我的领域真的无关紧要.

所以,现在如果我把它作为ShortCircuitMultiply(0.0, longOperation)地方longOperation是Func<double>,上学期将不进行评估和操作的结果将是有效为零.

问题是,正如我已经说过的,我会有很多ShortCircuitMultiply调用,我想让代码更具可读性.我希望代码与可能的代码类似0.0 * longOperation().

---

另一个注意事项:我已经尝试构建包装器double并创建隐式转换以加倍并且还重载*运算符.我明白,这可能是多余的:我想要实现可读性,但试图建立另一个包装器.无论如何,下一个代码演示了我的意图:

class MyDouble
{
    double value;
    public MyDouble(double value)
    {
        this.value = value; 
    }

    public static MyDouble operator *(MyDouble left, MyDouble right) 
    {
        Console.WriteLine ("* operator call");
        return new MyDouble(left.value * right.value);
    }

    public static implicit operator double(MyDouble myDouble)
    {
        Console.WriteLine ("cast to double");
        return myDouble.value;
    }

    public static implicit operator MyDouble(double value)
    {
        Console.WriteLine ("cast to MyDouble");
        return new MyDouble(value);
    }
}

现在,如果我去:

MyDouble zero = 0;

Console.WriteLine (zero * longOperation()); //longOperation is still Func<double>

我收到了:

cast to MyDouble            
called longOperation        <-- want to avoid this (it's printed from longOperation body)
cast to double             
cast to MyDouble
* operator call
cast to double   
0

但正如您所看到的,longOperation在调用重载运算符之前很久就会对其进行求值,并且我无法用其中一个参数替换Func或Expression使其变为惰性.

Answer 1

没有办法轻松做你想做的事.C#语言是一种非常"渴望"的语言,它总是在运行操作符之前评估操作数,即使你注意到,你也可以通过了解另一个来跳过它.唯一的例外是? :,及其等价物&&,||和??.(所有这些都可以减少到? :.)

正如你正确指出的那样,你可以通过使用lambda来达到懒惰; a Func<T>代表T将按需计算的.但正如你也正确地指出的那样,这样做的语法相当重要.

如果你必须有懒惰的算术,请考虑在Haskell中编写程序.它非常懒惰,我收集它很容易定义自己的运算符语义.F#也是一个选项,对于C#程序员来说可能更容易学习.

Answer 2

您的MyDouble包装类的问题是您通过longOperation直接调用来使用它.由于*不是短路,它将被直接调用.

相反,您可以让您的包装器接受a Func<double>作为第二个参数而不是double值本身.所以它会像ShortCircuitMultiply函数一样工作:

public static MyDouble operator *(MyDouble left, Func<double> right)
{
    return Math.Abs(left.value) < epsilon ? new MyDouble(0) : new MyDouble(left.value * right());
}

然后你会像这样使用它:

MyDouble x = 0;
Console.WriteLine(x * LongOperation);

甚至链接工作:

MyDouble x = 5;
Console.WriteLine(x * OperationReturingZero * LongOperation);

完整的例子

class Program
{
    static void Main()
    {
        MyDouble x = 0;
        Console.WriteLine(x * LongOperation);

        MyDouble y = 5;
        Console.WriteLine(y * OperationReturningZero * LongOperation);

        Console.ReadLine();
    }

    private static double LongOperation()
    {
        Console.WriteLine("LongOperation");
        return 5;
    }

    private static double OperationReturningZero()
    {
        Console.WriteLine("OperationReturningZero");
        return 0;
    }
}

class MyDouble
{
    private static double epsilon = 0.00000001;
    private double value;

    public MyDouble(double value)
    {
        this.value = value;
    }

    public static MyDouble operator *(MyDouble left, Func<double> right)
    {
        Console.WriteLine("* (MyDouble, Func<double>)");
        return Math.Abs(left.value) < epsilon ? new MyDouble(0) : new MyDouble(left.value * right());
    }

    public static MyDouble operator *(MyDouble left, MyDouble right)
    {
        Console.WriteLine("* (MyDouble, MyDouble)");
        return new MyDouble(left.value * right.value);
    }

    public static implicit operator double(MyDouble myDouble)
    {
        Console.WriteLine("cast to double");
        return myDouble.value;
    }

    public static implicit operator MyDouble(double value)
    {
        Console.WriteLine("cast to MyDouble");
        return new MyDouble(value);
    }
}

输出:

cast to MyDouble
* (MyDouble, Func<double>)
cast to double
0
cast to MyDouble
* (MyDouble, Func<double>)
OperationReturningZero
* (MyDouble, Func<double>)
cast to double
0