C# 使用继承并修改某些函数中的参数

我需要创造数学问题。算术，比较2个数字。。每个类都包含类似的功能，如CheckTheAnswer和GenerateProblem，但每个类都接收不同的参数。下面是我正在尝试做的一个例子

public class Problem<T>
{
    public virtual bool CheckTheAnswer()
    {
        return false;
    }

    public static T GenerateProblem()
    {
        return T;
    }
}

public class Arithmetic : Problem<Arithmetic>
{
    public bool CheckTheAnswer(decimal result)
    {
        ...
    }

    public static Arithmetic GenerateProblem(Tuple<int, decimal, decimal> condition)
    {
        ...
    }
}

public class Comparison2Numbers : Problem<Comparison2Numbers>
{
    public bool CheckTheAnswer(decimal result1, decimal result2)
    {
        ...
    }

    public static Comparison2Numbers GenerateProblem(Tuple<decimal, decimal> condition)
    {
        ...
    }
}

公共类问题
{
公共虚拟bool CheckTheAnswer（）
{
返回false；
}
公共静态T生成问题（）
{
返回T；
}
}
公共课算术：问题
{
公共布尔检查答案（十进制结果）
{
...
}
公共静态算术生成器问题（元组条件）
{
...
}
}
公共类比较：问题
{
公共布尔检查答案（十进制结果1，十进制结果2）
{
...
}
公共静态比较生成问题（元组条件）
{
...
}
}

我在考虑接口，但我意识到接口不能有静态函数。 提前谢谢

好的，问题是。。有办法做到这一点吗

Arithmetic a = new Arithmetic();
Problem<Arithmetic> p = a;

算术a=新算术（）；
问题p=a；

---

并从算术类中获取函数。也许这不是概括这些问题的最好方法，你认为呢？

我认为这是一种问题，你可能希望为你的生成器建立一个抽象工厂，而不是静态方法。您可以使用各个工厂的构造函数传递具有不同参数的数据。不过，每种方法都有一个固定的Create方法

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

接口IProbleFactory，其中T:IProblem
{
T Create（）；
}

---

类算术问题工厂：IProblemFactory
{
私有元组条件；
公共算术问题工厂（元组条件）{
这个条件=条件
}
算术IProbleFactory.Create（）{
...
}
}

我认为这是一种问题，您可能希望为生成器创建一个抽象工厂，而不是静态方法。您可以使用各个工厂的构造函数传递具有不同参数的数据。不过，每种方法都有一个固定的Create方法

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

接口IProbleFactory，其中T:IProblem
{
T Create（）；
}

---

类算术问题工厂：IProblemFactory
{
私有元组条件；
公共算术问题工厂（元组条件）{
这个条件=条件
}
算术IProbleFactory.Create（）{
...
}
}

为了获得多态创建的行为，抽象因子模式是最好的选择。有关如何设置的示例，请参见Mark的答案

但是你也需要能够用不同数量的参数来检查答案。从您的示例中，似乎您总是希望每个参数都有一种

decimal

。假设这是正确的，您可以使用变量法来检查答案。我还建议添加一个多态属性来访问所需数量的参数。因此，我们现在有：

public abstract class Problem<T>
{
    public abstract int ResultCount { get; }
    public abstract bool CheckTheAnswer(params decimal[] results);
}

公共抽象类问题
{
公共抽象int ResultCount{get；}
公共摘要bool CheckTheAnswer（参数十进制[]结果）；
}

基类可以是：

public class Arithmetic : Problem<Arithmetic>
{
    public override int ResultCount
    {
        get
        {
            return 2;
        }
    }

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

公共类算法：问题
{
公共覆盖int ResultCount
{
得到
{
返回2；
}
}
公共覆盖布尔检查答案（参数十进制[]结果）
{
if（results.Length！=ResultCount）
抛出新的ArgumentException（“仅应为”+ResultCount+“参数”）；
...
}
}

---

虽然这在参数数量上不提供编译时类型安全性，但它允许您使用运行时保证来解决问题。

要获得多态创建的行为，抽象因子模式最适合于此。有关如何设置的示例，请参见Mark的答案

但是你也需要能够用不同数量的参数来检查答案。从您的示例中，似乎您总是希望每个参数都有一种

decimal

。假设这是正确的，您可以使用变量法来检查答案。我还建议添加一个多态属性来访问所需数量的参数。因此，我们现在有：

public abstract class Problem<T>
{
    public abstract int ResultCount { get; }
    public abstract bool CheckTheAnswer(params decimal[] results);
}

公共抽象类问题
{
公共抽象int ResultCount{get；}
公共摘要bool CheckTheAnswer（参数十进制[]结果）；
}

基类可以是：

public class Arithmetic : Problem<Arithmetic>
{
    public override int ResultCount
    {
        get
        {
            return 2;
        }
    }

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

公共类算法：问题
{
公共覆盖int ResultCount
{
得到
{
返回2；
}
}
公共覆盖布尔检查答案（参数十进制[]结果）
{
if（results.Length！=ResultCount）
抛出新的ArgumentException（“仅应为”+ResultCount+“参数”）；
...
}
}

---

虽然这在参数数量上不提供编译时类型安全性，但它允许您使用运行时保证来解决问题。

我看不出任何问题。这根本不起作用。您不能覆盖

静态

方法，也不能向子类中的

虚拟

方法添加/更改参数，并且仍然将它们设置为

覆盖

s。我看不到任何问题。这根本不起作用。您不能重写

静态

方法，也不能向子类中的

虚拟

方法添加/更改参数，并且仍然使它们成为

重写

方法。当然，我正在寻找一种方法来制造这些问题。抽象工厂是最好的方法。当然，我一直在寻找一种方法来制造这些问题。抽象工厂是最好的方法。好吧，参数不会总是十进制的，它会更像对象。不过你的想法很好。我有两个问题：1为什么更好的问题像抽象类而不是接口？假设结果是一个对象