为什么这个泛型类会产生编译器错误？

Question

我有这门课：

public class Transform<PositionType, RotationType, ScaleType>
    where PositionType : Position
    where RotationType : Rotation
    where ScaleType : Scale
{
    public Transform<PositionType, RotationType, ScaleType> Parent;

    public PositionType GlobalPosition;
    // The next line has a compile error: Cannot implicitly convert type 'Position' 
    // to 'PositionType'.  An explicit conversion exists (are you missing a cast?)
    public PositionType LocalPosition => Parent.GlobalPosition - GlobalPosition;

    public RotationType GlobalRotation;
    // The next line has a compile error: Cannot implicitly convert type 'Rotation' 
    // to 'RotationType'. An explicit conversion exists (are you missing a cast?)
    public RotationType LocalRotation => Parent.GlobalRotation - GlobalRotation; 

    public ScaleType GlobalScale;
    // The next line has a compile error: Cannot implicitly convert type 'Scale' 
    // to 'ScaleType'. An explicit conversion exists (are you missing a cast?)
    public ScaleType LocalScale => Parent.GlobalScale - GlobalScale; 
}

Position：（Scale和Rotation定义相同）

public class Position
{
    public Position(int axis)
    {
        Axis = new float[axis];
    }

    public Position(float[] axis)
    {
        Axis = axis;
    }

    public static Position operator -(Position a, Position b)
    {
        if (a.Axis.Length != b.Axis.Length)
        {
            throw new System.Exception("The axis of the two Positions are not comparable.");
        }

        Position difference = new Position(a.Axis);

        for (int i = 0; i < difference.Axis.Length; i++)
        {
            difference.Axis[i] = a.Axis[i] - b.Axis[i];
        }

        return difference;
    }

    public float[] Axis;
}

对我来说这看起来完全有效，所以我很困惑为什么它会产生编译时错误。 在保留此功能的同时，我应该如何解决此问题？

Answer 1

您可以使用接口执行此操作，但您必须在每个派生类中实现减法逻辑。

public interface ISubtractable<T>
{
    T Subtract(T subtrahend);
}

public abstract class Position
{
    public float[] Axis;

    public Position(int axis)
    {
        Axis = new float[axis];
    }

    public Position(float[] axis)
    {
        Axis = axis;
    }
}

public class DerivedPosition : Position, ISubtractable<DerivedPosition>
{
    public DerivedPosition(int axis)
        : base(axis)
    { }

    public DerivedPosition(float[] axis)
        : base(axis)
    { }

    public DerivedPosition Subtract(DerivedPosition subtrahend)
    {
        if(Axis == subtrahend.Axis)
        {
            throw new System.Exception("The axis of the two Positions are not comparable.");
        }

        DerivedPosition difference = new DerivedPosition(Axis);

        for (int i = 0; i < difference.Axis.Length; i++)
        {
            difference.Axis[i] = Axis[i] - subtrahend.Axis[i];
        }

        return difference;
    }
}

public class Transform<TPosition, TRotation, TScale>
    where TPosition : ISubtractable<TPosition>
    where TRotation : ISubtractable<TRotation>
    where TScale : ISubtractable<TScale>
{
    public Transform<TPosition, TRotation, TScale> Parent;

    public TPosition GlobalPosition;

    public TPosition LocalPosition => Parent.GlobalPosition.Subtract(GlobalPosition);

    // etc.
}

Answer 2

我可能是错的，但是如果您将局部变量名称更改为与类型不同会发生什么 --- 例如

 public PositionType myPosition;
 public PositionType LocalPosition => Parent.myPosition - myPosition;

Answer 3

您的用例是什么样的，我不清楚您是否需要将其设为通用？ Position、Rotation 和 Scale 是基类吗？

public class Transform
{
    public Transform Parent;

    public Position GlobalPosition;

    public Position LocalPosition => Parent.GlobalPosition - GlobalPosition;

    public Rotation GlobalRotation;

    public Rotation LocalRotation => Parent.GlobalRotation - GlobalRotation; 

    public Scale GlobalScale;

    public Scale LocalScale => Parent.GlobalScale - GlobalScale; 
}