Question

也许标题没有意义。我正在创建工厂，其中一个是抽象的。 Abstract包含一个Random变量，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泛型值的类。

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

我的意思是，每个具体工厂都需要一个utils或objects容器来设置程序。 Binary和TimesTablesFactory需要两个绑定属性。

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

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

Answer 1

我认为你的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);

所以这一切都归结为你需要如何消费这一切。这篇文章的寓意是，如果你需要的只是配置，就没有必要尝试在抽象工厂中进行鞋拔配置，所有工厂应该做的就是创建实例并知道要创建什么类型，这就是它，但是你可以不是真的需要它:)）
祝你好运！

如何解决这个工厂模型的不一致？

1 个答案: