有没有可能避免情绪低落?

我有一些逻辑,它定义并使用一些用户定义的类型,如:

class Word
{
  System.Drawing.Font font; //a System type
  string text;
}

class Canvass
{
  System.Drawing.Graphics graphics; //another, related System type
  ... and other data members ...
  //a method whose implementation combines the two System types
  internal void draw(Word word, Point point)
  {
    //make the System API call
    graphics.DrawString(word.text, word.font, Brushes.Block, point);
  }
}

对类型进行计算后的逻辑(例如,定位每个类型 Word 实例),间接使用 System 例如,通过调用 Canvass.draw 方法。

我想让这个逻辑独立于 System.Drawing 名称空间:主要是为了帮助进行单元测试(我认为单元测试的输出更容易验证 draw 方法被绘制成一个非真实的 System.Drawing.Graphics 实例)。

以消除逻辑对 系统图 命名空间,我想声明一些新的接口作为 系统图 类型,例如:

interface IMyFont
{
}

interface IMyGraphics
{
  void drawString(string text, IMyFont font, Point point);
}

class Word
{
  IMyFont font; //no longer depends on System.Drawing.Font
  string text;
}

class Canvass
{
  IMyGraphics graphics;  //no longer depends on System.Drawing.Graphics
  ... and other data ...

  internal void draw(Word word, Point point)
  {
    //use interface method instead of making a direct System API call
    graphics.drawText(word.text, word.font, point);
  }
}

如果我这样做,那么不同的程序集可以有不同的 IMyFont 和 IMyGraphics 接口,例如…

class MyFont : IMyFont
{
  System.Drawing.Font theFont;
}

class MyGraphics : IMyGraphics
{
  System.Drawing.Graphics theGraphics;

  public void drawString(string text, IMyFont font, Point point)
  {

    //!!! downcast !!!

    System.Drawing.Font theFont = ((MyFont)font).theFont;

    //make the System API call
    theGraphics.DrawString(word.text, theFont, Brushes.Block, point);
  }
}

…然而,实现将需要一个如上图所示的向下转换。

我的问题是, 有没有一种方法可以做到这一点而不需要在实现中进行向下强制转换? “这个”,我的意思是“像这样定义UDT” 词 和 Canvass 不依赖具体的混凝土 系统 “类型”?

另一种选择是抽象的UDT…

class Word
{
  //System.Drawing.Font font; //declared in a subclass of Word
  string text;
}

class Canvass
{
  //System.Drawing.Graphics graphics; //declared in a subclass of Canvass
  //concrete draw method is defined in a subclass of Canvass
  internal abstract void draw(Word word, Point point); 
}

…但这也需要在子类的实现中进行向下转换。

我还考虑过使用双分派习惯用法,但这取决于在API中命名不同的子类。

或者,如果没有接口或子类,有没有使用委托的方法?

——编辑:

有两个可能的答案。

一个答案是使用仿制药,正如下面“兰蒂斯爵士”的答案所建议的,以及约翰·斯基特链接的博客文章所建议的。我怀疑这在大多数情况下都会起作用。从我的观点来看,这意味着 TFont 作为模板参数:它不仅是类 词 (其中包含 Font 实例),它需要成为一个泛型类(如 WordT<TFont> )也就是任何包含 wordt<tfont> (例如) Paragraph )现在还需要成为通用的 字体 参数(例如) ParagraphT<TFont> )最终,程序集中的几乎每个类都成为了通用类。这个 做 保护类型安全,避免向下投射… 但是 它有点难看,并且扰乱了封装的假象(认为“字体”是不透明的实现细节的假象)。

另一个答案是在用户类中使用映射或字典。而不是 字体 在可重用库中,而不是抽象接口中,定义一个“handle”类,如下所示:

public struct FontHandle
{
  public readonly int handleValue;
  FontHandle(int handleValue)
  {
    this.handleValue = handleValue;
  }
}

然后,而不是从 FontHandle 保持一个 Dictionary<int, Font> 映射的实例 芬太尔 值到 字体 实例。