如何改进这种设计（模式）？

Question

我创造的数学问题的软件。如你所知，数学问题有很多种。

在我的软件，一些问题是从一个XML文件（库）得到，并且可以由工厂产生anothers（随机数，你懂的）。

例如，如果我创建二进制问题补充，如果我选择了第一个选项，我可以有一个类从哪里得到THRE文件，并选择其中的一些。或者如果我选择第二个，我可以随机生成问题：

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，因为我需要知道服务是工厂还是存储库。在这种情况下，我会向文件提交一些问题。

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

你可以给你opinnion或想法，以改善它？

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

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

Answer 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); 

Answer 2

它看起来像你想要有不同的问题来源（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); 
    } 
} 

要使用它，只是实例化一个repository类，产生一个问题，它添加到列表中，并提交清单到仓库：

var problems = new List<Problems>(); 
var problem = ProblemFactory.GenerateRandom(); 
problems.Add(problem); 
var repository = new MemoryRepositoryService(); //or XmlRepositoryService 
repository.Submit(problems);