c# - 如何为基于策略模式的应用程序编写清晰优雅的代码？

Question

我正在编写一个应用程序来创作音乐，但我有点担心代码中类和接口(interface)的结构。这里有我写的一些类的签名:

Interface IGuidoFormattable
Class Note : IGuidoFormattable, ICloneable
Class Pause : IGuidoFormattable, ICloneable
Class Chord : List<Note>, IGuidoFormattable, ICloneable
Class Key : IGuidoFormattable, ICloneable
Class Tempo : IGuidoFormattable, ICloneable
Class Meter : IGuidoFormattable, ICloneable
Class FretPiece : List<IGuidoFormattable>, ICloneable
Class Fret : List<FretPiece>

FretPiece 代表一个音乐乐句，一个完整的 freize 片段。它公开为属性 Key、Tempo 和 Meter，它们与它们的类型同音。更多的短语放在一起会创建一个 freize，由 Fret 类表示。单个短语中的每个元素都必须根据 GUIDO 标准符号进行格式化，因此它必须实现 IGuidoFormattable 接口(interface)。在另一个命名空间中，定义了一些变异类，它们都继承自两个抽象类之一:

Class FretMutation
Class LambdaFretMutation : FretMutation

最后，存在一个名为 FretMutationGenerator 的类，它的唯一任务是将选定的突变应用于音乐主题并将整个 freize 输出为 Fret 类的实例。

FretPiece 必须能够包含几个不同的元素(在本例中为音符、暂停和和弦)，但它们必须满足两个约束:它们必须可以使用 GUIDO 符号进行格式化，因此可以转换为有意义的字符串；他们必须是可克隆的。在现在的代码中，每个类都实现了 ICloneable，但当前代码的语法和语义并未授予集合的所有成员都是可克隆的。我需要找到一种方法来表达这两种约束，而无需对 IGuidoFormattable 应用继承，最好不要在 IGuidoFormattable 接口(interface)中定义 Clone 方法。

第二个也是最重要的问题。 FretMutation 定义了一个抽象方法“Apply”，它必须在每个派生类中被覆盖。因此，任何变异类都定义了该方法的自己的版本，它具有以下签名:

FretPiece Apply(FretPiece originalTheme)

它接受 FretPiece 作为输入并输出该对象的副本，根据指定为该类成员的所有其他参数进行变异。我认为这是策略模式的一种实现。然而，仅由于此方法创建输入的副本这一事实，这意味着参数本身(及其所有成员)必须是可克隆的。此外，FretPiece 被声明为 IGuidoFormattable 列表，但每个突变类的行为都与其他类不同，并且可能对音符、停顿或和弦起作用，相应地:这意味着我需要检查每个元素的类型，并为每种类型都有“很多”(实际上，最多 3 个)if 语句。在我看来，这似乎很少面向对象。

我怎样才能以一种更加面向对象并且更少依赖假设和类型检查的方式来安排类和接口(interface)？

Answer 1

I need to find a way to express both constraint without applying inheritance to IGuidoFormattable and preferably without defining a Clone method in the IGuidoFormattable interface

第三个选项呢？

public interface ICloneableAndGuidoFormattable : IGuidoFormattable, ICloneable { }

那么你的 FretPiece 就是 List Of ICloneableAndGuidoFormattable

如果不是那样，您可以尝试这样的构造:

public interface ICloneable<T>
{
  T Clone();
}

public class FretPiece : IEnumerable<IFormattable>, ICloneable<FretPiece>
{
    private List<IFormattable> items = new List<IFormattable>();

    public void Add<T>(T value) where T : IFormattable, ICloneable<IFormattable>
    {
        items.Add(value);
    }

    public IEnumerator<IFormattable> GetEnumerator()
    {
        items.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    public FretPiece Clone()
    {
        return new FretPiece { items = new List<IFormattable>(
            items.Cast<ICloneable<IFormattable>>().Select(c=>c.Clone()))
        };
    }
}

还有其他地方，例如在你的突变体上:

public T Apply<T>(T fretPiece) where T : IEnumerable<IFormattable>, ICloneable<T> ( ...)

这将确保您只能添加实现这两个接口(interface)的项目。枚举仅假定返回 IFormattables。这将允许您在类型转换内部安全地转换为 ICloneable，因为它必须已经通过了“添加”的类型约束。可以看到clone的实现。即使你在那里有类型转换，它也是安全的，除非有人根据反射摆弄 items ;)