这是什么设计模式？

Question

很久以前我做过一次，当时我遵循了一个设计模式。 现在，我需要再做一次，我真的不记得我以前是怎么做的，也想不出帮助我做这件事的模式。

我有一个包含大量变量/属性的类。 有些是基于其他计算的，并且这些属性之间会进行各种交叉计算。

当我第一次实例化时一切都很好 - 所有的值和计算都很好。 我的问题是，当一个值发生变化时，我希望从中派生的所有计算值都能根据新值自动更新。 如果我不需要，我不想手动编写每个单独的重新计算 - 每当这个类被更新或添加时，它就会成为很多开销，试图追踪你需要传播任何更改的所有位置你在做。

我想你跟着我。

无论如何，谁能想到是什么模式使这成为可能？ 我发誓我曾经知道它。 估计变老了。

// Like this...
class foo
{
    decimal A = 1233;
    decimal B = 42;

    decimal C = A / B; // I want this to update whenever
                       // the value of either A or B changes.
    decimal D = 123;
    decimal E = 321;

    decimal F = D + E; // I don't want this one to change when
                       // A or B or even C for that matter changes,
                       // and I don't wan to have to cycle through
                       // all of the calculated values that don't
                       // need to change just for find the few that do.
}

Answer 1

观察员。 您需要在模型上使用某种.Subscribe()方法来注册回调 - 在您的特定情况下，这些只是采用新值并基于该值重新计算其他一些值的函数。 只要你的编程环境有rxjs实现，我强烈建议坚持使用那个。 否则你会因为多线程和内存泄漏而受苦。

Answer 2

我建议避免在这里过度设计。 您作为示例提供的内容有 6 个成员，它们之间具有简单的依赖关系，可以轻松地重新计算。 我确实理解这可能只是一个简化的例子，所以让我们的目标是例如 10-20 个成员，以及不需要数据库查找或磁盘访问的依赖项（作为较重的操作的一个例子）。

您可以将所有依赖项放入一个方法中（我们称之为Update ），如果任何成员被修改，您将调用该方法。 为了不用担心记得调用Update() ，您将所有成员移动到一个单独的“状态”类中：

class FooState
{
    private int _a;

    public int A
    {
        get { return _a; }
        set
        {
            _a = value;
            Update();
        }
    }

    private int _b;

    public int B
    {
        get { return _b; }
        set
        {
            _b = value;
            Update();
        }
    }

    public double C { get; private set; }

    // other members

    private void Update()
    {
        C = A * B + 3;
        // other updates
    }
}

class Foo
{
    private FooState _state;

    public Foo()
    {
        _state.A = 1;
        _state.B = 2;
        Debug.Write($"C = {_state.C}");
    }
}

你得到什么：

• 发生了什么事情马上就清楚了。 对于任何会碰巧修改此代码的人。
• 成员之间的所有依赖项都在一个方法中，易于阅读，易于修改。 您的业​​务逻辑不会被这些细节污染。
• 你不能忘记重新计算你的依赖成员。
• 是的，您可以进行比严格要求更多的重新计算，因为即使不相关的成员被修改，您也会重新计算所有依赖成员。 在我在真实文件中看到的大多数类似案例中，这不是问题。
• 如果您有循环依赖（这是另一回事），则此方法不起作用。

随意实现“观察者”模式并进行比较。

我不认为这种简单的方法有名字。 不要将它与有点不同的“状态”模式混淆。