Gestion de plusieurs modèles interdépendants

Question

J'essaie de gérer plusieurs modèles dans un système basé sur la messagerie. Chaque modèle peut avoir des valeurs dépendantes d'autres modèles. Par exemple:

public class V2Model : BaseModel 
    { 
     private int mSomeVal; 
     private byte mSomeByte; 

     // … 

     // Update mSomeByte based on multiple models values 
     public void SetMultipleDependecyValue(int someIntFromModel1, short someShawteeyFromModel3) 
     { 
     mSomeByte = Convert.ToByte((someShawteeyFromModel3/someIntFromModel1) + mSomeVal); 
     } 
    } 

Je voudrais également utiliser le modèle MVC, mais au lieu de passer une instance de modèle, je pensais que je passerais dans une instance « dépôt ». L'instance 'Repository' agirait comme un gestionnaire pour gérer toutes les instances du modèle. Le résultat ressemblerait à quelque chose comme ceci:

public class V1Controller<ViewType, ModelType> 
     where ViewType : IV1View 
     where ModelType : BaseModel 
    { 
     ViewType mView; 
     BaseRepository mBaseRep; 

     public V1Controller(ViewType view, BaseRepository rep) 
     { 
     mView = view; 
     mBaseRep = rep; 
     mBaseRep.GetModel<ModelType>().PropertyChanged += new PropertyChangedEventHandler(V1ModelPropertyChanged); 
     } 

     void V1ModelPropertyChanged(object sender, PropertyChangedEventArgs e) 
     { 
     switch (e.PropertyName) 
     { 
      case "SomeVal": 
       // Update the view 
       int some_val = mBaseRep.GetModel<ModelType>().SomeVal; 
       mView.HexSomeValue = some_val; 
       // Oh BTW, we know V2Model's value depends on this... update it with V1Model and V3Model's values 
       short some_short = mBaseRep.GetModel<V3Model>().SomeShawteey; 
       mBaseRep.GetModel<V2Model>().SetMultipleDependecyValue(some_val, some_short); 
       break; 
     } 
     } 

     public void UpdateVal(int someValue) 
     { 
     mBaseRep.GetModel<ModelType>().SomeVal = someValue; 
     } 
    } 

Dans cette situation, si la propriété de V1Model a changé, en V1ModelPropertyChanged, je sais la dépendance sur l'objet de V2Model, et le mettre à jour avec les valeurs appropriées. Y a-t-il une meilleure façon de gérer ce modèle de modèle interdépendant, ou serait-ce une solution acceptable? Je ne cherche pas vraiment de tiers.

Answer 1

Si vous voulez gérer cela élégamment, vous aurez besoin d'avoir un certain composant pour suivre les dépendances entre les modèles. Lorsqu'une propriété est modifiée, vous devez parcourir toutes les dépendances de cette propriété, puis les mettre à jour de manière appropriée.

Peut-être que votre BaseRepository pourrait contenir une référence à une classe DependencyManager. Cette classe devrait avoir une liste de toutes les propriétés qui dépendent les unes des autres.

Une implémentation simple pourrait ressembler à ceci:

class PropertyDescriptor 
{ 
    public Type ModelType { get; set; } 
    public string Property { get; set; } 
} 

class DependencyManager 
{ 
    private Dictionary<PropertyDescriptor, List<PropertyDescriptor>> _dependencies = new Dictionary<PropertyDescriptor, List<PropertyDescriptor>>(); 

    public void RegisterDependency(PropertyDescriptor property, PropertyDescriptor dependentProperty) 
    { 
     if (!_dependencies.ContainsKey(property)) 
     { 
      _dependencies.Add(property, new List<PropertyDescriptor>()); 
     } 
     _dependencies[property].Add(dependentProperty); 
    } 

    public IEnumerable<PropertyDescriptor> GetDependentProperties(PropertyDescriptor property) 
    { 
     if (!_dependencies.ContainsKey(property)) 
     { 
      yield break; 
     } 
     else 
     { 
      foreach (PropertyDescriptor p in _dependencies[property]) 
      { 
       yield return p; 
      } 
     } 
    } 
} 

Puis, quand vous détectez un changement de propriété, vous pouvez interroger le DependencyManager pour ce qu'il reste à changer. Mais attention à vérifier les dépendances circulaires lorsque vous cascadez!

Answer 2

Peut-être qu'il me manque quelque chose, mais n'est-ce pas ce à quoi sert le observer pattern? Si vous configurez les modèles en tant qu'observateurs les uns des autres (c'est-à-dire avec des délégués ou des événements), le contrôleur doit pouvoir rester parfaitement ignorant des dépendances.