2

我正在为数学问题创建一个软件。如你所知，数学问题有很多种。

在我的软件中，一些问题来自 Xml 文件（存储库），而另一些问题可以由工厂生成（随机数，你知道）。

例如，如果我正在创建二进制问题作为补充，如果我选择第一个选项，我可以有一个类来获取文件并选择其中的一些。或者，如果我选择第二个，我可以随机生成问题：

x = random.Next(y, z);
y = random.Next(y, z);

return new BinaryProblem(x, y);

类似的东西。

所以我现在开发了这个设计，我想我已经建立了一个策略模式。

public interface IProblemService
{
    IEnumerable<Problem> GetProblems();
}

public class ProblemService : IProblemService
{
    private readonly IService service;

    public ProblemService(IService service)
    {
        this.service = service;
    }

    public IService Service
    {
        get { return service; }
    }

    public IEnumerable<Problem> GetProblems()
    {
        return this.service.GetProblems();
    }
}

/* =====================================================*/
CONCRETE CLASSES

public interface IService
{
    IEnumerable<Problem> GetProblems();
}

// When I want to generate random problems
public abstract class FactoryService : IService
{
    public IEnumerable<Problem> GetProblems();
    public abstract Generate();
}

// When I want to get problems through a XML file
public class RepositoryService : IService
{
    public abstract IEnumerable<Problem> GetProblems();
    void Submit(IEnumerable<Problem> problems);
}

在服务中，我将 IService 设为公开，因为我需要知道该服务是工厂还是存储库。如果这将是一个存储库，我会向文件提交一些问题。

我不相信这个设计。我想我是多余的，这不是最好的方法。

你能给出你的意见或想法来改进它吗？

编辑：我对第一个选项的意思是：

    public IEnumerable<Problem> GetProblems()
    {
        if (model == null)
        {
            model = new List<Problem>();

            // Dummy Data.
            model.Add(new SimplifyProblem() { Id = "1", Expression = "8 ÷ 2 x 5 ÷ 10", Result1 = 2 });
            model.Add(new SimplifyProblem() { Id = "2", Expression = "20 ÷ 2 x 5 - 2", Result1 = 48 });
            model.Add(new SimplifyProblem() { Id = "3", Expression = "15 ÷ 5 + 3", Result1 = 6 });
            model.Add(new SimplifyProblem() { Id = "4", Expression = "6 + 4² ÷ 8 - 2", Result1 = 6 });
            model.Add(new SimplifyProblem() { Id = "5", Expression = "8 + 2 x 4", Result1 = 40 });
            model.Add(new SimplifyProblem() { Id = "6", Expression = "8 + 4 x (5 - 3)", Result1 = 16 });
            model.Add(new SimplifyProblem() { Id = "7", Expression = "8 - 3 + 5", Result1 = 10 });
            // ...
        }

        return model;
    }
4

2 回答 2

1

我不知道为什么你有两个单独的接口，IProblemService并且IService; 对我来说，似乎他们做同样的事情。

我会将随机问题的生成（“工厂”部分）与实际返回问题的类（“存储库”部分）分开：

public interface IProblemRepository {
  IEnumerable<Problem> LoadProblems();
}

public class XmlProblemRepository : IProblemRepository {
  ...
}

public class InMemoryProblemRepository : IProblemRepository {
  private readonly IEnumerable<Problem> problems;

  public InMemoryProblemRepository(IEnumerable<Problem> problems) {
    this.problems = problems;
  }

  public IEnumerable<Problem> LoadProblems() {
    return problems;
  }
}

public class RandomProblemFactory {
  public IEnumerable<Problem> GenerateProblems(int count) {
    ...
  }
}

然后您可以从 XML 文件加载：

repository = new XmlProblemRepository("problems.xml");

或者您可以使用工厂生成问题并从内存存储库中获取它们：

factory = new RandomProblemFactory();
problems = factory.GenerateProblems(10);
repository = new InMemoryProblemRepository(problems);
于 2012-07-10T04:00:28.510 回答
0

看起来您希望有不同的问题来源（Xml 文件、数据库、内存）并使您的代码持久性无知。如果是这样，我不会IService在工厂类中实现接口。保留工厂仅用于随机问题生成。我将添加Submit到界面：

public interface IService
{
    IEnumerable<Problem> GetProblems();
    void Submit(IEnumerable<Problem>);
}

该类XmlRepositoryService将从/到 XML 文件中获取/保存数据：

public class XmlRepositoryService : IService
{
    public IEnumerable<Problem> GetProblems()
    {
      //get the problems from the Xml file
    }

    public void Submit(IEnumerable<Problem> problems)
    {
      //save problems to the xml file
    }
}

内存存储库类将存储问题列表：

public class MemoryRepositoryService : IService
{
    private List<Problem> problemList = new List<Problem>();

    public IEnumerable<Problem> GetProblems()
    {
      return problemList;
    }

    public void Submit(IEnumerable<Problem> problems)
    {
      problemList.AddRange(problems.ToList());
    }
}

该类ProblemFactory将GenerateRandom只有方法：

public class ProblemFactory
{
  public static Problem GenerateRandom()
  {
    var x = random.Next(y, z);
    var y = random.Next(y, z);

    return new BinaryProblem(x, y);
  }
}

要使用它，只需实例化一个存储库类，生成问题，将其添加到列表并将列表提交到存储库：

var problems = new List<Problems>();
var problem = ProblemFactory.GenerateRandom();
problems.Add(problem);
var repository = new MemoryRepositoryService(); //or XmlRepositoryService
repository.Submit(problems);
于 2012-07-10T04:10:52.407 回答