Collection.Removeitem与ItemClass.Remove是否有约定俗成或仅是口味问题？ 重构之前重构后

如何解决Collection.Removeitem与ItemClass.Remove是否有约定俗成或仅是口味问题？ 重构之前重构后

在下面的示例中，我通过创建其他类来重构代码，这些类将接管主要类（Geometry）的某些职责。希望遵循SoC原则。

注释：

• Geometry类具有字段（nodes和radii），这些字段保存将被解释为抽象对象（如 Point ，拱形或线。
• 类Point，Arch和Line继承于抽象类GeoEntity，该抽象类对Geometry类具有依赖关系，并通过对其构造函数进行依赖注入。

重构之前

public class Geometry
{
    private List<Vector2> nodes;
    private Dictionary<int,double>[] radii;

    public void DrawLine() { // Do the magic.}
    public void InsertPoint() { // Do the magic.}
    public void InsertArch() { // Do the magic.}

    public void TranslateNode(double dx,double dy) { // Do the magic.}
    public void TranslateLine(double dx,double dy) { // Do the magic.}

    public void RemoveNode(int index) { // Do the magic.}
    public void RemoveLine(int index) { // Do the magic.}
    public void RemoveArch(int index) { // Do the magic.}

    public void DoSpecialNodeRelatedAction1() { // Do the magic.}
    public void DoSpecialNodeRelatedAction2() { // Do the magic.}
    public void DoSpecialLineRelatedAction(double someValue) { // Do the magic.}
}

重构后

public class Geometry
{
    private List<Vector2> nodes;
    private Dictionary<int,double>[] radii;

    public Geometry.Point[] Points { get => // Get them magically. }
    public Geometry.Line[] Lines { get => // Get them magically. }
    public Geometry.Arch[] Arches { get => // Get them magically. }

    public void DrawLine() { // Do the magic.}
    public void InsertPoint() { // Do the magic.}
    public void InsertArch() { // Do the magic.}


    public abstract class GeoEntity
    {
        private readonly Geometry geometry;

        protected GeoEntity(Geometry geometry,int index) 
        {
            this.geometry = geometry;
            this.Index = intex;
        }

        public int Index { get; }

        protected abstract void DoSpecificDeletion();        
        public void Delete()
        {
            DoSpecificDeletion();
            geometry.nodes.Remove(Index);
            
            var exists = radii.TryGetValue(Index,out var kvp);
            if(exists) radii.Remove(Index);
        }
    }

    public class Point : GeoEntity
    {
        internal Point(Geometry geometry,int Index) : 
            base(geometry,index) {}

        protected override void DoSpecificDeletion() { // Do the magic.}
        public void Translate(double dx,double dy) { // Do the magic.}
        public void DoSpecialAction1() { // Do the magic.}
        public void DoSpecialAction2() { // Do the magic.}
    }

    public class Line : GeoEntity
    {
        internal Line(Geometry geometry,double dy) { // Do the magic.}
        public void DoSpecialAction(double someValue) { // Do the magic.}
    }

    public class Arch: GeoEntity
    {
        internal Arch(Geometry geometry,index) {}

        protected override void DoSpecificDeletion() { // Do the magic.}
    }
}

---

在这种情况下，重构应强制执行SoC原则，从而形成具有多个较小类的更简洁的结构，每个较小类负责以其特定方式更改Geometry类中的数据，而不是将所有方法都定义为{{ 1}}类。

示例中显示了我发现的一个可能的问题：

Geometry

但是，从OOP的角度来看，我不确定这是否可以接受。

我很好奇这种实现是否会导致更易于出错的解决方案。