通过泛型与多态的代码重用

Question

重用实现的更好方法是什么：继承还是泛型？

模型如下：脚本有步骤，步骤有元素。树结构是双重链接的，即步骤知道他们的脚本和元素现在他们的步骤。

现在，有两种类型的脚本：模板和运行，其中运行首先创建为模板的副本。这会产生 2 个类似的层次结构 ScriptTemplate->ScriptTemplateStep->ScriptTemplateElement 和 ScriptRun->ScriptRunStep->ScriptRunElement。大多数功能是通用的，但各种类可能有一些附加属性。

为了重用功能，我可以开发由 ScriptRun 和 ScriptTemplate 派生的抽象 Script 类，例如：

abstract class Script { IList<Step> Steps; }
class ScriptRun : Script {}
class ScriptTemplate : Script {}

class Step { Script Script; IList<Element> Elements; }
class ScriptRunStep : Step {}
class ScriptTemplateStep : Step {}

或者我可以试试泛型：

abstract class Script<TScript, TStep, TElement> 
where TScript:Script<TScript, TStep, TElement>
where TStep:Step<TScript, TStep, TElement> 
where TElement:Element<TScript, TStep, TElement>
{ IList<TStep> Steps; }

abstract class Step<TScript, TStep, TElement> 
where TScript:Script<TScript, TStep, TElement>
where TStep:Step<TScript, TStep, TElement> 
where TElement:Element<TScript, TStep, TElement>
{ TScript Script; IList<TElement> Elements; }

class ScriptRun : Script<ScriptRun, ScriptRunStep, ScriptRunElement> {}
class ScriptRunStep : Step<ScriptRun, ScriptRunStep, ScriptRunElement> {}
class ScriptRunElement : Element<ScriptRun, ScriptRunStep, ScriptRunElement> {}

class ScriptTemplate : Script<ScriptTemplate, ScriptTemplateStep, ScriptTemplateElement> {}
class ScriptTemplateStep : Step<ScriptTemplate, ScriptTemplateStep, ScriptTemplateElement> {}
class ScriptTemplateElement : Element<ScriptTemplate, ScriptTemplateStep, ScriptTemplateElement> {}

泛型方法的缺点：

1. 起初看起来有点复杂。尤其是糟糕的地方。
2. 一开始似乎不熟悉。
3. DataContractSerializing 时带来一点乐趣。
4. 组件更大。

优点：

1. 类型安全：您将无法将 ScriptTemplateElement 添加到 ScriptRunStep。
2. 不需要从集合项转换为具体类型。此外 - 更好的智能感知支持。 ScriptTemplate.Steps 立即属于 ScriptTemplateStep，而不是抽象 Step。
3. 遵守 Liskov 原则：在继承场景中，ScriptRun 上有 IList 集合，但确实不应该在其中添加 ScriptTemplateStep，尽管它显然是一个 Step。
4. 您不必进行覆盖。例如。假设您想在脚本上有一个 NewStep 方法。在前一种情况下，您说

：

abstract class Script { abstract Step NewStep(); }

abstract class ScriptRun { 
    override Step NewStep(){ 
        var step = new ScriptRunStep(); 
        this.Steps.Add(step); 
        return step; 
    } 
}

abstract class ScriptTemplate { 
    override Step NewStep(){ 
        var step = new ScriptTemplateStep(); 
        this.Steps.Add(step); 
        return step; 
    } 
}

在你写的泛型场景中：

abstract class Script<TScript, TStep, TElement> 
where TScript:Script<TScript, TStep, TElement>
where TStep:Step<TScript, TStep, TElement>, new()
where TElement:Element<TScript, TStep, TElement>
{ 
    TStep NewStep() {
        var step = new TStep();
        this.Steps.Add(step);
        return step;
    }
}

ScriptRun 和 ScriptTemplate 自动拥有该方法，或者更好的方法：返回类型分别为 ScriptRunStep 和 ScriptTemplateStep 而不是简单的 Step。

Answer 1

我发现泛型通过泛型属性促进组合，而无需为您想要利用的每个组合编写不同的类，也不必创建冗长的继承树。在可能的情况下，我会尽量支持组合而不是继承，尤其是在单继承平台中。

我会说你的情况需要两者兼而有之。可能类似于以下内容：

类 Child { TParent 父级； } 类父 { IList 孩子； } 类 ParentAndChild : Parent { TParent Parent; } 类元素：Child { ... } 类步骤：ParentAndChild

Answer 2

两者都没有。重用实现的最佳方式是聚合。

之后，模板是否适用取决于问题。我的经验法则是，任何产生最少代码的东西都会更好。至少，这是我的经验。

[编辑] 对于如此复杂的问题，这可能是一个简短的答案。

但是，特别是对于这种情况（这似乎主要是关于重用父子层次结构的逻辑，你可以写

 IChildOf<TPARENT> 
 { TPARENT Parent {get; set;} }


 sealed class Children<TPARENT,TCHILD> : where TCHILD: IChildOf<TPARENT>
 {
      // .... details omitted 
      public void Add(TCHILD child)
      { 
          // add child to internal collection, then:

          child.Parent = parent;
      }

      readonly TPARENT parent;
 }

TPARENT 将有一个 Children 集合作为成员，并将一个指向自身的指针传递给它。该集合确保每个TCHILD 都有对其父级的引用。

Answer 3

看看你的优缺点列表 - 我怀疑你已经知道答案了。缺点通常是“我对此不熟悉”、“效率不高”的形式，而优点是“它对我的代码强制执行更严格的结构”的形式。我说，总是选择使代码更健壮的那个，那就是泛型。