C# 混淆类层次结构中显式类型转换的必要性

Question

我有两个类 Vector 和 Point，其中 Point 是 Vector 的子类。我有一个方法 Scale 用于 Vector(因此也用于 Point)和一个方法 Clone 用于 Point 返回深拷贝。

public class Vector
{
    protected double x, y, z;

    public Vector(double x, double y, double z)
    {
        this.x = x; this.y = y; this.z = z;
    }

    public Vector Scale(double sc)
    {
        this.x = sc * x; this.y = sc * y; this.z = sc * z;
        return this;
    }
}

public class Point : Vector
{
    public Point(double x, double y, double z) : base(x, y, z) { }

    public Point Clone()
    {
        return new Point(this.x, this.y, this.z);
    }
}

(注:实际代码比这复杂，方法多很多，但这段摘录应该足以说明问题，请不要建议任何继承层次结构的改变或将类变成结构体。我有已经和我的同事一起评估了这些问题。)

现在我将以下内容写入我的主程序:

Point p = new Point(1, 2, 3);
Point q = p.Clone().Scale(2); // compile error complaining about missing cast

第二行可以这样修复:

Point q = p.Clone().Scale(2) as Point;

但我的问题是我不明白为什么这是必要的。 这就是我认为编译器所做的:

p 是一个点。 p.Clone() 是另一个Point。我们检查是否存在方法 Point.Scale(double)。我们找不到，所以我们检查父类(super class)是否有这样的方法，即方法 Vector.Scale(double) 是否存在。我们查看 Vector.Scale 并发现它返回 this。由于 p.Clone() 是一个 Point，我们知道 p.Clone().Scale(2) 的返回值将是p.Clone() 本身(但已修改)，因此它必须是一个 Point。瞧，不需要强制转换。

• 那么问题是什么，为什么编译器不能推断出我不需要任何强制转换？
• 我该如何解决才能让用户不必每次都转换？实现此目的的唯一方法是编写方法 Point.Scale(double) 吗？我知道我可以通过重定向到 Vector.Scale(double) 使其成为单行代码，但由于新方法的额外文档注释，我将产生额外费用，因此这是不可取的。
• 这种转换只是一种形式主义，这样编译器就不会提示，还是实际上会在内部做任何事情？我的意思是像移动内存或分配/取消分配内存，或任何计算？

Answer 1

这是因为推断类型是最后执行的函数的返回类型(最右边的函数，或者在您的情况下返回 Vector 的 Scale() 方法)而不是点)

---

为了不必在每次调用缩放方法时都进行强制转换，您可以使用泛型。

一个例子是:

public abstract class Scalable<T>
{
    protected double x, y, z;

    public T Scale(double sc)
    {
        this.x = sc * x; this.y = sc * y; this.z = sc * z;
        return this;
    }

    public Scalable(double x, double y, double z)
    {
        this.x = x; this.y = y; this.z = z;
    }
}

该类将定义使对象可扩展所需的内容，它被定义为抽象的，因此开发人员无法创建该类的实例，只能继承它。

然后您的其他两个类将相应地更改:

public class Vector : Scalable<Vector>
{
    public Vector(double x, double y, double z) : base(x,y,z)
    {
    }
}

和

public class Point : Scalable<Point>
{
    public Point(double x, double y, double z) : base(x, y, z) { }

    public Point Clone()
    {
        return new Point(this.x, this.y, this.z);
    }
}

另一种更简单的方法是简单地定义一个调用 Vector one 并一次性转换的 scale 方法:

public class Point : Vector
{
    public Point(double x, double y, double z) : base(x, y, z) { }

    public Point Clone()
    {
        return new Point(this.x, this.y, this.z);
    }

    public Point Scale(double sc)
    {
        return (Point)base.Scale(sc);
    }
}

---

第三个问题:

编译器不知道你在方法内部做了什么，它只知道返回的是什么类型。

因此，它不能保证返回的对象可以转换为Point对象。

你必须写的转换是为了告诉编译器:“别担心，我知道这个对象是我给你指出的类型”