Question

我在C＃.NET中编写工程应用程序。通常，这些应用程序具有复杂的更新机制，至少我最终会编写复杂的更新机制。

任何人都可以指导我阅读一些我可以学习更新理论的书吗？我应该花时间学习递归函数吗？异步更新？二叉树？我甚至在停车场进入球场吗？

我喜欢使用属性，因为它们似乎是自包含的，并且很容易和干净地绑定到我写的WPF和silverlight gui，我喜欢事件，因为它似乎减少了意大利面，但我不觉得我的理论理解这些事情非常合理。

感谢您的帮助！

这是我正在谈论的那种事情的一个例子。

public delegate void ParentChangedEventHandler(object sender, EventArgs e);

public class Parent
{
    List<Child> Children;

    private double parentCoefficient;
    public double ParentCoefficient
    {
        get
        {
            return parentCoefficient;
        }
        set
        {
            parentCoefficient = value;
            ParentChanged(this, EventArgs.Empty);
        }
    }

    public double Chaos
    {
        get
        {
            double chaos = 0;
            foreach(Child child in Children)
            {
                chaos += child.ChildChaos;
            }
            return chaos;
        }
    }

    public event ParentChangedEventHandler ParentChanged;

    public Parent()
    {
        ParentCoefficient = 42;
        Children = new List<Child>();
        for (int i = 0; i < 12; i++)
        {
            Children.Add(new Child(this));
        }            
    }
}

public class Child
{
    public double ChildChaos;
    private Parent parent;

    public Child(Parent theParent)
    {
        parent = theParent;
        parent.ParentChanged += new ParentChangedEventHandler(parent_Changed);
    }

    private void parent_Changed(object sender, EventArgs e)
    {
        ChildChaos = 0.5 * parent.ParentCoefficient;
    }
}

因此，您会注意到，在更改Parent类时，子项需要更新，然后父项需要在更改子项时进行更新。如果我通过将其注册到子项中的事件来更新父项，则它将针对每个子项更新一次，此时它应该仅在所有子项更新后更新。

我相信你们中的一些人可以为这个特殊问题提出解决方案，但请记住，这是一个简化的例子。真实的要复杂得多。

我真的可以用一本书来介绍这类事情的基本理论。

Answer 1

在我看来，你在谈论复杂的状态依赖关系，它可以由规则引擎高效建模。现代规则引擎基本上采用一组输入，对其应用一组规则，其中一些规则再次对先前应用的规则的输出起作用，并生成符合这些规则的输出。

在您的情况下，您有一条规则可以在父实体更改时强制执行“混乱”的累积。例如，当“混乱”达到阈值或其他任何时候，这可能会触发其他一些规则。

复杂的依赖关系管理很好，因为规则是明确的。我通过实验使用的一个好的规则引擎是DROOLS.Net。 Inrule也是一个商业广告：http://www.inrule.com/

更新机制理论

1 个答案: