支持的操作设计模式

Question

我有一个抽象类“A”，它具有枚举类型“OutputType”的属性，还有一个抽象方法calculation（），它需要执行certin计算，并根据OutputType值以double[]**形式输出结果。

我也有一个类定义为D1，D2，D3...D20，从A派生，其中每个Di类实现A的计算（）方法不同。

问题是并非所有的OutputType值（calculation（）输出类型）都在每个Di中都受支持

例如：

如果OutputType枚举值为“缩放”、“非缩放”和“恒定长度”，

一个认证Di可以支持“缩放”和“非缩放”，但不支持“恒定长度”，另一个Di可以支持所有操作类型，

我的问题是：

实现这种行为的正确设计模式是什么

请避免明显的“如果输出类型属性接收到不支持的操作的值，则抛出”回答。

编辑：

扩展问题：

有没有一种方法可以用intellisense通知用户所有支持的操作，这样用户就不必采取试错法？（除了适当的文件）

Answer 1

请注意，我已经编辑了我的答案，完全放弃了我以前使用代码契约的先决条件的方法。

我一直在想一个应该更强大的解决方案。

一个抽象类为每个可能的操作类型定义了一个受保护的虚拟方法，一个不可覆盖的公共计算方法可以调用覆盖的受保护的虚拟方法呢？

public abstract class Calculation
{
    public Calculation()
    {
        // I store all overridable methods in a dictionary where keys
        // are the method names
        OverridableMethods = new Dictionary<string, Func<double[]>>()
        {
            { nameof(CalculateScaled), CalculateScaled },
            { nameof(CalculateNonScaled), CalculateNonScaled },
            { nameof(CalculateConstantLength), CalculateConstantLength }
        };


        // Then we get the first overriden method. If there're more
        // than one, it will pick the first occurence and others will be
        // discarded. It's up to the developer to override just one.
        MethodInfo overridenMethod = OverridableMethods.Keys
                .Select(methodName => GetType().GetMethod(methodName, BindingFlags.Instance | BindingFlags.NonPublic))
                .FirstOrDefault(method => method.DeclaringType != typeof(Calculation));

        Contract.Assert(overridenMethod != null, "No calculation operation implementation has been provided");

        // So some method was overriden and I store the method name
        OverridenMethodName = overridenMethod.Name;
    }

    private string OverridenMethodName { get; }
    private Dictionary<string, Func<double[]>> OverridableMethods { get; }

    protected virtual double[] CalculateScaled() 
    {
        throw new NotImplementedException();
    }

    protected virtual double[] CalculateNonScaled() 
    {
        throw new NotImplementedException();
    }

    protected virtual double[] CalculateConstantLength()
    {
        throw new NotImplementedException();
    }

    // Calculate just access the overridable method dictionary
    // to get the overriden method encapsulated by a Func<double[]>
    // and I immediately call it!
    public double[] Calculate() => OverridableMethods[OverridenMethodName]();
}

public class SomeCalculation : Calculation
{
    protected override double[] CalculateScaled()
    {
        return new double[] { 22 };
    }
}

所以它真的有效！

    Calculation calculation = new SomeCalculation();

    // Prints out 22!
    Console.WriteLine(calculation.Calculate()[0]);