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

时间：2012-01-27 19:07:00

标签： c# design-patterns factory factory-pattern

也许标题没有意义。我正在创建工厂，其中一个是抽象的。 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枚举，值将是条件（绑定对象）。

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

1 个答案:

答案 0 :(得分：2)

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

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

祝你好运！

相关问题
最新问题