摘要基层或帮助班

Question

我今天刚刚学习了一些关于组合而不是继承的知识。我想知道我是否应该把这个概念应用到我最近写的东西上。

我们以前的有两个类几乎是相同的，除了几个小的差异。它们包含一些基本的数据库访问特性，但对不同(但相关)对象类型进行操作。因此，我们以前有这样的类的结构：

class BallMillDBHandler{

    public BallMillDBHandler(){ ... }

    public void InsertTool(BallMill tool) { ... }
    public BallMill QueryTool(string toolID) { ... }
    public void UpdateTool(BallMill tool) { ... }
    public void DeleteTool(string toolID) { ... }
}

class DiamondToolDBHandler{

    public DiamondToolDBHandler(){ ... }

    public void InsertTool(DiamondTool tool) { ... }
    public DiamondTool QueryTool(string toolID) { ... }
    public void UpdateTool(DiamondTool tool) { ... }
    public void DeleteTool(string toolID) { ... }
}

我将大多数几乎重复的方法重新分解成一个BaseToolDBHandler()类，并从另外两个类继承它，提供了一些抽象方法和属性来处理访问数据库参数本身的差异。

将BaseToolDBHandler改为包含在数据库访问器中的帮助类，并为它们提供一个公共接口(以前的抽象属性/方法)是否有意义？还是我应该把它作为继承的案例？

Answer 1

这看起来像是一种通过基类/接口同时受益于泛型和继承的场景。

class DBHandler<TTool> where TTool : ToolBase // or ITool
{
    public DBHandler(){ ... }

    public void InsertTool(TTool tool) { ... }
    public TTool QueryTool(string toolID) { ... }
    public void UpdateTool(TTool tool) { ... }
    public void DeleteTool(string toolID) { ... }
}

如果需要，您可以创建一个基类(可选抽象)类，或者作为类型约束使用的接口，以保证某些成员需要在方法体中拥有所需的工具。

示例：

var handler = new DBHandler<BallMill>();
BallMill value = handler.QueryTool("xyz");
value.SomeProperty = "New Value";
handler.UpdateTool(value);

Answer 2

继承确实会被过度使用，但这似乎是一个合适的案例。在许多情况下，人们只看到重复的代码，并认为“我将使用继承来通过基类删除重复的代码”。实际上，大多数重复的代码可以完全重构到另一个类中，这些类在几个地方都使用过。通常，使用它的类并不“相关”，它们正在做两件完全不同的事情，只是碰巧需要执行一些(或一系列)小任务。

当类真正可以说类“是”基类的实例时，应该使用继承，而不仅仅是一些需要访问其他地方定义的方法的类。在您的特殊情况下，很明显，这两个类都是DB处理程序。在它们的症结所在，它们都为相同的一般目标服务，但它们是实现该目标的两个不同的可能实现。我在这里看到的唯一问题(考虑到您还没有展示任何方法的内容)是，您可能能够将两个类组合成一个类，但是我们需要了解更多的细节，才能知道这是可能的还是可取的。

Answer 3

我要说的是，这绝对是inheritance...but的任务，让我们先搞清楚一件事。组合是一种设计模式，可以而且应该在类的多重继承不是给定语言的特性的情况下使用(例如C#)。

组合意味着您的复合类实例化类，这些类通常是继承的。在这种情况下，您通过接口将契约提供给实现。

要给出如何将继承应用于代码的粗略示例，请考虑以下内容：(这不是使用组合)

public interface IHandler
{
    void InsertTool(ITool tool);
    void UpdateTool(ITool tool);
    void DeleteTool(string toolID);
    //void DeleteTool(ITool tool) - seems more consistent if possible!?

    ITool QueryTool(string toolID);
}

public interface ITool
{

}

class BallMill : ITool
{
}

class DiamondTool : ITool
{
}

class BallMillDBHandler : IHandler
{

    public BallMillDBHandler(){ ... }

    public void InsertTool(ITool tool) { ... }
    public BallMill QueryTool(string toolID) { ... }
    public void UpdateTool(ITool tool) { ... }
    public void DeleteTool(string toolID) { ... }
}

class DiamondToolDBHandler : IHandler
{

    public DiamondToolDBHandler(){ ... }

    public void InsertTool(ITool tool) { ... }
    public DiamondTool QueryTool(string toolID) { ... }
    public void UpdateTool(ITool tool) { ... }
    public void DeleteTool(string toolID) { ... }
}