Question

我在两种引用类型之间有明确的转换设置。

class Car
{
    public void Foo(Car car)
    {

    }

    public static explicit operator Bike(Car car)
    {
        return new Bike();
    }

}

class Bike
{

}

如果我调用Foo并传递Bike类型，那么我必须执行显式转换。

            Car myCar = new Car();
            Bike bike = (Bike)myCar;            
            myCar.Foo(bike);//Error: Cannot convert from Bike to Car.

但是，如果我添加扩展方法，则不再需要显式转换。

        public static void Foo(this Car car, Bike bike)
        {
            car.Foo(bike);//Success...
        }

为什么扩展方法能够隐式调用类型为Bike的Foo？

Answer 1

为什么扩展方法能够隐式调用类型为Bike的Foo？

不是。您提供的代码会导致编译器错误。

至少有以下一种情况属实：

您在此处提供的代码不是您尝试编译的代码。
您在代码中进行了隐式转换，但未在此处添加。
您实际上没有编译过您的代码，也没有注意到它无法编译。

Answer 2

现在您已修改代码以显示;

public static void Foo(this Car car, Bike bike)
{
    car.Foo(bike);//Success...
}

你所做的就是创造一个具有讽刺意味的StackOverflowException。此方法现在只是递归调用自身，而不是Foo中Car的实现。

提示：给自己一份ReSharper - 它会在这行代码上放一个漂亮的圆圈箭头图标，告诉你发生了什么，而不需要编译或运行它。： - ）

Answer 3

不应该在Bike上定义显式转换吗？

class Bike
{
    public static explicit operator Bike(Car car)
    {
        return new Bike();
    }
}

这允许：

Car myCar = new Car();
Bike myBike = (Bike) myCar;

如果您希望能够在不指定转化的情况下执行此操作，则应使用implicit关键字。

Car myCar = new Car();
Bike myBike = myCar;

最后，您收到错误的地方//Error: Cannot convert from Bike to Car.这表明您需要进行逆转换......

class Car
{
    // FROM Bike TO Car
    public static explicit operator Car(Bike bike)
    {
        return new Car();
    }
}

为什么扩展方法会绕过显式转换的需要？

3 个答案: