不知道如何组织我的课程

这只是我代码中的一个例子。我正在寻找一种好方法来维护我的类的顺序，并遵循一些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的类，aritic类包含了一个数学问题所包含的所有必要元素，以及如何解决这个问题:

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");
        }
    }
}

问题是……我需要有更多的属性，如结果(在算术类中只需要1个，在比较2个数字时我们需要两个属性结果)，问题编号，时间(秒)来解决问题。

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

ArithmeticProblem

• 问题问题<——这里是算术类

结果

• 题

我只是想按照必须的方式组织我的课程。

public class Arithmetic < TResult> : ...

public class Addition : Arithmetic <decimal>
...