Question

以下是我的代码中的一个示例。我正在寻找一种很好的方法来按顺序维护我的课程并遵循一些OOP规则。

这是我的抽象类问题：

public abstract class Problem<T> : IEquatable<T>
{
    public abstract int ResultCount { get; }
    protected abstract bool CheckTheAnswer(params object[] results);
    public abstract bool Equals(T other);
}

下面是一个派生自Problem的类，Arithetic类包含数学问题中包含的所有必要内容，以及如何解决它：

public enum Operations
{
    Addition, Subtraction, Multiplication, Division
}

public class Arithmetic : Problem<Arithmetic>
{
    public decimal Number1
    {
        get;
        set;
    }

    public Operations Operation
    {
        get;
        set;
    }

    public decimal Number2
    {
        get;
        set;
    }

    public override int ResultCount
    {
        get { return 1; }
    }

    protected override bool CheckTheAnswer(params object[] results)
    {
        if (results.Length != ResultCount)
            throw new ArgumentException("Only expected " + ResultCount + " arguments.");

        decimal result = (decimal)results[0];

        switch (Operation)
        {
            case Operations.Addition:
                return Number1 + Number2 == result;
            case Operations.Subtraction:
                return Number1 - Number2 == result;
            case Operations.Multiplication:
                return Number1 * Number2 == result;
            case Operations.Division:
                return Number1 / Number2 == result;
            default:
                throw new Exception("Operator unexpected");
        }
    }

    public override bool Equals(Arithmetic other)
    {
        if (other == null)
            return false;

        return this.Number1 == other.Number1 && Number2 == other.Number2;
    }
}

public class Addition : Arithmetic
{
    public Addition(decimal addend1, decimal addend2)
        : base()
    {
        Number1 = addend1;
        Number2 = addend2;
        Operation = Operations.Addition;
    }
}

// Subtraction, Multiplication and Divison here

然后我有另一个生成算术问题的类，它接收一个元组，其中包含一些指示条件的属性

interface IProblemFactory<T> where T : Problem<T>
{
    T Create();
}

public class ArithmeticProblemFactory : IProblemFactory<Arithmetic>
{
    private Tuple<Operations, Range, Range> _condition;

    public ArithmeticProblemFactory(Tuple<Operations, Range, Range> condition)
    {
        this._condition = condition;
    }

    public Arithmetic Create()
    {
        Operations operation = _condition.Item1;
        decimal a = _condition.Item2.GetNumber();
        decimal b = _condition.Item3.GetNumber();

        switch (operation)
        {
            case Operations.Addition:
                return new Addition(a, b);
            case Operations.Subtraction:
                return new Subtraction(a, b);
            case Operations.Multiplication:
                return new Multiplication(a, b);
            case Operations.Division:
                return new Division(a, b);
            default:
                throw new Exception("Operator unexpected");
        }
    }
}

事情是......我需要有更多属性，比如Result（在算术类中只需要1，比较2个数字，我们需要两个属性结果），问题编号，时间（秒）来解决问题。 / p>

问题是，我不知道应该把这些属性放在哪里。一种方法是在Problem类中添加其中一些，或者创建另类类似这样的类：

ArithmeticProblem

问题问题＆lt; - 这是算术类
结果
时间
问题编号

我只想组织我的课程。提前谢谢。

Answer 1

您可以为结果设置不同的类，并且在算术类中接受结果类型为通用：

public class Arithmetic < TResult> : ...

和Addition可以如下：

public class Addition : Arithmetic <decimal>
...

但是如果参数的数量（如结果，时间，...）没有固定（动态），你可以有一个字典并将它们存储在字典（它们的类型）中并编写特定的动作并将它们设置为字典的值

Answer 2

我建议在问题类中放置结果，时间（生成或解决）和问题编号。每个问题都有自己的结果，时间和数量;他们也可以包括在内。这使您无需将另一个类链接到每个问题以及具有全包问题类。

怀疑如何组织我的课程

2 个答案: