C#中如何建模存在循环依赖的齿轮类？

问题背景 #

我正在开发一款生成机械齿轮轮廓的应用，核心问题是齿轮不能作为独立实体建模——单个齿轮的部分几何参数（比如变位系数）必须依赖于啮合的其他齿轮才能确定。

当前类结构 #

我的InvoluteGear类定义如下：

{
    private double _moduleM; // 法向模数
    private double _teethZ; // 齿数
    private double _profileShift; // 非标准中心距的变位系数
    private double _helixAngle; // 斜齿轮螺旋角
    private InvoluteGear _matingGear;
    ...
    // 其他公共方法
}

现有实现的痛点 #

目前有一个独立的计算类，其中标准中心距的计算代码如下：

/// <summary>
/// 标准中心距是指未做齿廓调整时，主动轮与从动轮中心之间的法向距离
/// </summary>
public static double StandardCentreDistanceA(InvoluteGear g1) =>
    ((g1.TeethZ + g1.MatingGear.TeethZ) / (2 * Math.Cos(Radians(g1.HelixAngleBeta)))) * g1.ModuleM;

这段代码能正常运行，但g1.MatingGear.TeethZ的链式调用过于繁琐，显然存在更优的建模方式。此外还有更复杂的场景：外啮合、内啮合齿轮的计算公式不同，单个齿轮的特性会直接改变计算逻辑。我曾尝试引入GearPair类，但它仅适用于双齿轮场景，希望找到能适配多啮合齿轮（比如行星轮系）的通用方案。

优化建模方案建议 #

1. 引入GearTrain轮系核心类 #

创建GearTrain作为轮系的容器，负责管理所有关联齿轮及啮合关系，齿轮类不再直接持有单个啮合伙伴的引用，而是通过轮系获取关联对象。

public class GearTrain
{
    private List<InvoluteGear> _gears = new List<InvoluteGear>();
    // 记录齿轮间的啮合关系：键为齿轮，值为与之啮合的齿轮集合
    private Dictionary<InvoluteGear, List<InvoluteGear>> _meshRelations = new Dictionary<InvoluteGear, List<InvoluteGear>>();

    public void AddGear(InvoluteGear gear)
    {
        _gears.Add(gear);
        gear.GearTrain = this; // 让齿轮关联到所属轮系
    }

    public void AddMeshRelation(InvoluteGear gearA, InvoluteGear gearB)
    {
        if (!_meshRelations.ContainsKey(gearA))
            _meshRelations[gearA] = new List<InvoluteGear>();
        _meshRelations[gearA].Add(gearB);

        if (!_meshRelations.ContainsKey(gearB))
            _meshRelations[gearB] = new List<InvoluteGear>();
        _meshRelations[gearB].Add(gearA);
    }

    // 针对特定齿轮对计算中心距，自动判断啮合类型
    public double CalculateStandardCentreDistance(InvoluteGear gearA, InvoluteGear gearB)
    {
        int meshSign = IsExternalMesh(gearA, gearB) ? 1 : -1;
        return ((gearA.TeethZ + meshSign * gearB.TeethZ) / (2 * Math.Cos(Radians(gearA.HelixAngle)))) * gearA.ModuleM;
    }

    private bool IsExternalMesh(InvoluteGear gearA, InvoluteGear gearB)
    {
        // 根据齿轮类型（外齿/内齿）判断啮合类型
        return gearA.IsExternalGear && gearB.IsExternalGear;
    }
}

public class InvoluteGear
{
    public GearTrain GearTrain { get; internal set; }
    public double ModuleM { get; private set; }
    public double TeethZ { get; private set; }
    public double ProfileShift { get; private set; }
    public double HelixAngle { get; private set; }
    public bool IsExternalGear { get; private set; } // 标记外齿/内齿

    public InvoluteGear(double moduleM, double teethZ, double helixAngle, bool isExternalGear)
    {
        ModuleM = moduleM;
        TeethZ = teethZ;
        HelixAngle = helixAngle;
        IsExternalGear = isExternalGear;
    }

    // 变位系数计算委托给外部类处理
    public double GetProfileShift(InvoluteGear matingGear)
    {
        return GearTrainCalculator.CalculateProfileShift(this, matingGear);
    }
}

2. 用策略模式分离场景计算逻辑 #

针对外啮合、内啮合、行星轮系等不同场景，封装独立的计算策略，避免轮系类中堆积大量条件判断。

public interface IGearCalculationStrategy
{
    double CalculateCentreDistance(InvoluteGear gearA, InvoluteGear gearB);
    double CalculateProfileShift(InvoluteGear gearA, InvoluteGear gearB);
}

public class ExternalMeshStrategy : IGearCalculationStrategy
{
    public double CalculateCentreDistance(InvoluteGear gearA, InvoluteGear gearB)
    {
        return ((gearA.TeethZ + gearB.TeethZ) / (2 * Math.Cos(Radians(gearA.HelixAngle)))) * gearA.ModuleM;
    }

    public double CalculateProfileShift(InvoluteGear gearA, InvoluteGear gearB)
    {
        // 外啮合场景下的变位系数计算逻辑
        ...
    }
}

public class InternalMeshStrategy : IGearCalculationStrategy
{
    public double CalculateCentreDistance(InvoluteGear gearA, InvoluteGear gearB)
    {
        return ((gearB.TeethZ - gearA.TeethZ) / (2 * Math.Cos(Radians(gearA.HelixAngle)))) * gearA.ModuleM;
    }

    public double CalculateProfileShift(InvoluteGear gearA, InvoluteGear gearB)
    {
        // 内啮合场景下的变位系数计算逻辑
        ...
    }
}

// 在GearTrain中动态切换计算策略
public class GearTrain
{
    private IGearCalculationStrategy _calculationStrategy;

    public void SetCalculationStrategy(IGearCalculationStrategy strategy)
    {
        _calculationStrategy = strategy;
    }

    public double CalculateStandardCentreDistance(InvoluteGear gearA, InvoluteGear gearB)
    {
        return _calculationStrategy.CalculateCentreDistance(gearA, gearB);
    }
}

3. 齿轮类职责单一化 #

让InvoluteGear只负责自身属性的维护，所有依赖其他齿轮的计算都交给轮系或专用计算类处理，避免齿轮类持有过多外部引用，降低耦合度。

这种设计的核心优势：

• 适配多啮合场景：轮系可管理任意数量的齿轮及啮合关系，支持行星轮系等复杂结构
• 代码可读性提升：计算逻辑与实体类分离，不同场景的计算逻辑可通过策略模式灵活切换
• 避免繁琐引用：不再需要链式调用g1.MatingGear.TeethZ，直接通过轮系获取关联齿轮完成计算

内容的提问来源于stack exchange，提问作者DBolsover