如何修复此工厂模型的不一致性

本文关键字：不一致性 模型 工厂 何修复 | 更新日期: 2023-09-27 18:21:34

也许标题没有意义。我在创建工厂，其中一个是抽象的。摘要包含一个随机变量和CanConfigureXLevel。这些默认值是false（我的意思是，不可用），但如果你想拥有它，只需将其重写为true即可。

public abstract class ProblemFactory 
{ 
    protected Random Random = new Random(); 
    public abstract IProblem Generate(); 
    public virtual bool CanConfigureEasyLevel()
    {
        return false;
    }
    public virtual bool CanConfigureMediumLevel()
    {
        return false;
    }
    public virtual bool CanConfigureHardLevel()
    {
        return false;
    }
    protected abstract void ConfigureEasyLevel();
    protected abstract void ConfigureMediumLevel();
    protected abstract void ConfigureHardLevel();
}

二元问题的一个具体类（生成加法）

public class BinaryProblemFactory : ProblemFactory 
{ 
    private Bound<int> _bound1; 
    private Bound<int> _bound2; 
    public BinaryProblemFactory(Level level) 
    { 
        // ... 
    } 
    public override IProblem Generate() 
    { 
        int x = random.Next(_bound1.Min, _bound1.Max); 
        int y = random.Next(_bound2.Min, _bound2.Max); 
        Operators op = Operators.Addition;
        return new BinaryProblem(x, y, operator, answer); 
    }
    public override bool CanConfigureMediumLevel()
    {
        return true;
    }
    public override bool CanConfigureHardLevel()
    {
        return true;
    }
    protected override void ConfigureEasyLevel()
    {
        // ...
    }
    protected override void ConfigureMediumLevel()
    {
        this._bound1 = new Bound<int>(10, 100); 
        this._bound2 = new Bound<int>(10, 100); 
    }
    protected override void ConfigureHardLevel()
    {
        this._bound1 = new Bound<int>(100, 1000); 
        this._bound2 = new Bound<int>(100, 1000); 
    }
}

Bound只是一个包含Min和Max泛型值的类。

请记住，BinaryProbemFactory包含一个Random属性。我正在创建几个数学问题，上面是加法问题，我也会创建时间表（非常类似于BinaryProblem，但这是乘法和不同的边界。

我的意思是，每个混凝土工厂都需要一个包含utils或对象的容器来设置程序。Binary和TimesTablesFactory需要两个绑定属性。

我的主要问题是…我需要在一个列表中显示哪些级别可用（只有两个以上，中等和硬级别）。我想如果我们维护一个字典，我可以修复它覆盖CanConfigureXLevel，其中键将是Level枚举，值将是条件（绑定对象）。

但我不确定我应该删除什么。我需要一点帮助。

如何修复此工厂模型的不一致性

我认为ProblemFactory可能试图做得太多了，工厂应该只负责创建实例和知道要创建哪些类型的实例，而不需要知道配置的额外开销。

考虑到这一点，我将如何处理这个问题：

/// <summary>
/// Each class that can generate a problem should accept a problem configuration
/// </summary>
public class BinaryProblem : IProblem
{
    public BinaryProblem (ProblemConfiguration configuration)
    {
        // sample code, this is where you generate your problem, based on the configuration of the problem
        X = new Random().Next(configuration.MaxValue + configuration.MinValue) - configuration.MinValue;
        Y = new Random().Next(configuration.MaxValue + configuration.MinValue) - configuration.MinValue;
        Answer = X + Y; 
    }
    public int X { get; private set; }
    public int Y { get; private set; }
    public int Answer { get; private set; }
}

为此，我们需要一个问题配置类

/// <summary>
/// A problem configuration class
/// </summary>
public class ProblemConfiguration
{
    public int MinValue { get; set; }
    public int MaxValue { get; set; }
    public Operator Operator { get; set; }
}

我还将创建一个专门的类来处理级别的配置，并将其从工厂类中删除。

/// <summary>
/// The abstract level configuration allows descendent classes to configure themselves
/// </summary>
public abstract class LevelConfiguration
{
    protected Random Random = new Random();
    private Dictionary<Level, ProblemConfiguration> _configurableLevels = new Dictionary<Level, ProblemConfiguration>();
    /// <summary>
    /// Adds a configurable level.
    /// </summary>
    /// <param name="level">The level to add.</param>
    /// <param name="problemConfiguration">The problem configuration.</param>
    protected void AddConfigurableLevel(Level level, ProblemConfiguration problemConfiguration)
    {
        _configurableLevels.Add(level, problemConfiguration);
    }
    /// <summary>
    /// Removes a configurable level.
    /// </summary>
    /// <param name="level">The level to remove.</param>
    protected void RemoveConfigurableLevel(Level level)
    {
        _configurableLevels.Remove(level);
    }
    /// <summary>
    /// Returns all the configurable levels.
    /// </summary>
    public IEnumerable<Level> GetConfigurableLevels()
    {
        return _configurableLevels.Keys;
    }
    /// <summary>
    /// Gets the problem configuration for the specified level
    /// </summary>
    /// <param name="level">The level.</param>
    public ProblemConfiguration GetProblemConfiguration(Level level)
    {
        return _configurableLevels[level];
    }
}

这将允许二进制配置看起来像这样：

/// <summary>
/// Contains level configuration for Binary problems
/// </summary>
public class BinaryLevelConfiguration : LevelConfiguration
{
    public BinaryLevelConfiguration()
    {
        AddConfigurableLevel(Level.Easy, GetEasyLevelConfiguration());
        AddConfigurableLevel(Level.Medium, GetMediumLevelConfiguration());
        AddConfigurableLevel(Level.Hard, GetHardLevelConfiguration());
    }
    /// <summary>
    /// Gets the hard level configuration.
    /// </summary>
    /// <returns></returns>
    private ProblemConfiguration GetHardLevelConfiguration()
    {
        return new ProblemConfiguration
        {
            MinValue = 100,
            MaxValue = 1000,
            Operator = Operator.Addition
        };
    }
    /// <summary>
    /// Gets the medium level configuration.
    /// </summary>
    /// <returns></returns>
    private ProblemConfiguration GetMediumLevelConfiguration()
    {
        return new ProblemConfiguration
        {
            MinValue = 10,
            MaxValue = 100,
            Operator = Operator.Addition
        };
    }
    /// <summary>
    /// Gets the easy level configuration.
    /// </summary>
    /// <returns></returns>
    private ProblemConfiguration GetEasyLevelConfiguration()
    {
        return new ProblemConfiguration
        {
            MinValue = 1,
            MaxValue = 10,
            Operator = Operator.Addition
        };
    }

}

现在，工厂应该只负责创建问题的新实例，并知道它可以为服务的问题类型

/// <summary>
/// The only responsibility of the factory is to create instances of Problems and know what kind of problems it can create, 
/// it should not know about configuration
/// </summary>
public class ProblemFactory
{
    private Dictionary<Type, Func<Level, IProblem>> _registeredProblemTypes; // this associates each type with a factory function
    /// <summary>
    /// Initializes a new instance of the <see cref="ProblemFactory"/> class.
    /// </summary>
    public ProblemFactory()
    {
        _registeredProblemTypes = new Dictionary<Type, Func<Level, IProblem>>();
    }
    /// <summary>
    /// Registers a problem factory function to it's associated type
    /// </summary>
    /// <typeparam name="T">The Type of problem to register</typeparam>
    /// <param name="factoryFunction">The factory function.</param>
    public void RegisterProblem<T>(Func<Level, IProblem> factoryFunction)
    {
        _registeredProblemTypes.Add(typeof(T), factoryFunction);
    }
    /// <summary>
    /// Generates the problem based on the type parameter and invokes the associated factory function by providing some problem configuration
    /// </summary>
    /// <typeparam name="T">The type of problem to generate</typeparam>
    /// <param name="problemConfiguration">The problem configuration.</param>
    /// <returns></returns>
    public IProblem GenerateProblem<T>(Level level) where T: IProblem
    {
        // some extra safety checks can go here, but this should be the essense of a factory,
        // the only responsibility is to create instances of Problems and know what kind of problems it can create
        return _registeredProblemTypes[typeof(T)](level); 
    }
}

下面是如何使用所有这些

class Program
{
    static void Main(string[] args)
    {
        ProblemFactory problemFactory = new ProblemFactory();
        BinaryLevelConfiguration binaryLevelConfig = new BinaryLevelConfiguration();

        // register your factory functions
        problemFactory.RegisterProblem<BinaryProblem>((level) => new BinaryProblem(binaryLevelConfig.GetProblemConfiguration(level)));
        // consume them
        IProblem problem1 = problemFactory.GenerateProblem<BinaryProblem>(Level.Easy);
        IProblem problem2 = problemFactory.GenerateProblem<BinaryProblem>(Level.Hard);
    }
}

当然，如果你只需要抽象你的配置，那么你可能不需要工厂，这完全取决于你打算如何使用它。

IProblem problem3 = new BinaryProblem(binaryLevelConfig.GetProblemConfiguration(Level.Easy));

可能的改进

除此之外，如果一个问题类总是有一个问题配置，则可以进一步改进为：

/// <summary>
/// Each class that can generate a problem should accept a level configuration
/// </summary>
public class BinaryProblem : IProblem
{
    private static BinaryLevelConfiguration _levelConfiguration = new BinaryLevelConfiguration();
    public BinaryProblem (Level level)
    {
        ProblemConfiguration configuration = _levelConfiguration.GetProblemConfiguration(level);
        // sample code, this is where you generate your problem, based on the configuration of the problem
        X = new Random().Next(configuration.MaxValue + configuration.MinValue) - configuration.MinValue;
        Y = new Random().Next(configuration.MaxValue + configuration.MinValue) - configuration.MinValue;
        Answer = X + Y; 
    }
    public int X { get; private set; }
    public int Y { get; private set; }
    public int Answer { get; private set; }
}

那么你所需要做的就是：

IProblem problem4 = new BinaryProblem(Level.Easy);

所以这一切都归结为你需要如何消费这一切。这篇文章的寓意是，没有必要在抽象工厂中尝试和强行配置，如果你只需要配置，工厂应该做的就是创建实例并知道要创建什么类型，仅此而已，但你可能并不真正需要它：）

祝你好运！

相关文章：