Théorie du mécanisme de mise à jour

Question

J'écris des applications d'ingénierie au travail en C# .NET. Souvent, ces applications ont des mécanismes de mise à jour complexes, au moins les I finissent par écrire des mécanismes de mise à jour complexes.

Quelqu'un peut-il me diriger vers des livres ou quelque chose où je peux apprendre la théorie des mises à jour? Devrais-je passer mon temps à apprendre sur les fonctions récursives? Mises à jour asynchrones? Arbres binaires? Suis-je même dans le parking pour entrer dans le stade? J'aime utiliser les propriétés parce qu'elles semblent autonomes et sont faciles et propres à se lier au WPF et aux gui silverlight que j'écris et j'aime les événements parce qu'il semble que cela réduit les spaghettis, mais je ne me sens pas comme mes théoriciens la compréhension de ces choses est très saine.

Merci pour l'aide!

Voici un exemple du genre de chose dont je parle.

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; 
    } 
} 

Alors, vous remarquerez que l'enfant a besoin d'une mise à jour lorsque la classe parente est modifiée, et le parent doit mettre à jour lorsque l'enfant est changé. Si je mets à jour le parent en l'enregistrant dans un événement de l'enfant, il sera mis à jour une fois pour chaque enfant, alors qu'il ne devrait être mis à jour que lorsque tous les enfants auront été mis à jour.

Je suis sûr que certains d'entre vous peuvent trouver des solutions à ce problème particulier, mais gardez à l'esprit qu'il s'agit d'un exemple simplifié. Les vrais sont beaucoup plus complexes.

Je pourrais vraiment utiliser un livre qui couvre la théorie fondamentale sur ce genre de chose.

Answer 1

Il me semble que vous parlez de dépendances d'états complexes, qui peuvent être modélisées efficacement par un moteur de règles. Un moteur de règles moderne prend essentiellement un ensemble d'entrées, lui applique un ensemble de règles, dont certaines agissent de nouveau sur la sortie des règles appliquées précédemment, et génère une sortie conforme à ces règles.

Dans votre cas, vous auriez une règle qui impose l'accumulation de "chaos" lorsque l'entité parente change. Cela pourrait, par exemple, déclencher une autre règle, par exemple, lorsque le «chaos» atteint un seuil ou peu importe.

Les dépendances complexes sont bien gérées car les règles sont déclaratives. Un bon moteur de règles que j'ai utilisé expérimentalement est DROOLS.Net. Inrule fait un commercial, aussi: http://www.inrule.com/