WinForms Databinding meilleures pratiques

Question

Demandes/problèmes:

1. Je voudrais lier plusieurs propriétés d'une entité à des contrôles dans un formulaire. Certains ne sont lus que de temps en temps (selon la logique métier). - Edit: La logique est basée sur l'instance liée, et pas seulement sur son type.
2. Lorsque vous utilisez une entité qui implémente INotifyPropertyChanged comme DataSource, chaque notification de changement Actualise tous les contrôles liés à cette source de données (facile à vérifier - il suffit de lier deux propriétés à deux contrôles et invoquer une notification de changement sur l'un d'eux, vous verrez que les deux propriétés sont frappées et réévaluées).
3. Il doit y avoir notifications d'erreur conviviales (l'entité implémente IDataErrorInfo). (Probablement en utilisant ErrorProvider)

Utilisation de l'entité comme DataSource des contrôles conduit à des problèmes de performance et rend la vie plus difficile quand il est temps pour un contrôle à lecture seule. J'ai pensé à créer une sorte de wrapper qui contient l'entité et une propriété spécifique pour que chaque contrôle soit lié à un DataSource différent. En outre, ce wrapper peut contenir l'indicateur ReadOnly pour cette propriété afin que le contrôle soit lié directement à cette valeur.

L'enveloppe pourrait ressembler à ceci:

interface IPropertyWrapper : INotifyPropertyChanged, IDataErrorInfo 
{ 
    object Value { get; set; } 

    bool IsReadOnly { get; } 
} 

Mais cela signifie aussi un ErrorProvider différent pour chaque propriété (wrapper propriété)

Je sens que je suis en train de réinventer la roue ... Quelle est la manière «appropriée» de gérer des demandes de reliure complexes comme celles-ci?

Merci d'avance.

Answer 1

Je n'envelopperais pas chaque propriété individuellement ... J'envelopperais l'objet de domaine racine. J'y implémenterais la logique en lecture seule ... et ne définirais la valeur que sur l'objet du domaine réel si l'indicateur readonly est défini sur false.

Answer 2

Vous pouvez écrire un wrapper pour votre entité qui implémente ICustomTypeDescriptor. De cette façon, vous pouvez décider quelles propriétés sont en lecture seule ou non ... mais c'est beaucoup de travail pour un scénario pas si complexe.

Une solution plus simple consisterait à remplacer DataSourceUpdateMode de la liaison par Never lorsque vous souhaitez que la propriété soit en lecture seule.

---

MISE À JOUR: voici un emballage de base mise en œuvre ICustomTypeDescriptor:

class EntityWrapper<T> : CustomTypeDescriptor 
{ 
    public EntityWrapper(T entity) 
    { 
     this.Entity = entity; 
     var properties = TypeDescriptor.GetProperties(typeof(T)) 
        .Cast<PropertyDescriptor>() 
        .ToArray(); 
     ReadOnly = properties.ToDictionary(p => p.Name, p => p.IsReadOnly); 
     _properties = new PropertyDescriptorCollection(properties 
          .Select(p => new WrapperPropertyDescriptor(p, this)) 
          .ToArray()); 
    } 

    public T Entity { get; private set; } 
    public Dictionary<string, bool> ReadOnly { get; private set; } 

    public override PropertyDescriptorCollection GetProperties() 
    { 
     return _properties; 
    } 

    public override PropertyDescriptorCollection GetProperties(Attribute[] attributes) 
    { 
     return _properties; 
    } 

    private PropertyDescriptorCollection _properties; 
    private class WrapperPropertyDescriptor : PropertyDescriptor 
    { 
     private EntityWrapper<T> _entityWrapper; 
     private PropertyDescriptor _property; 

     public WrapperPropertyDescriptor(PropertyDescriptor property, EntityWrapper<T> entityWrapper) 
      : base(property) 
     { 
      _property = property; 
      _entityWrapper = entityWrapper; 
     } 

     public override bool CanResetValue(object component) 
     { 
      return _property.CanResetValue(component); 
     } 

     public override Type ComponentType 
     { 
      get { return _property.ComponentType; } 
     } 

     public override object GetValue(object component) 
     { 
      return _property.GetValue(component); 
     } 

     public override bool IsReadOnly 
     { 
      get 
      { 
       return _entityWrapper.ReadOnly[this.Name]; 
      } 
     } 

     public override Type PropertyType 
     { 
      get { return _property.PropertyType; } 
     } 

     public override void ResetValue(object component) 
     { 
      _property.ResetValue(component); 
     } 

     public override void SetValue(object component, object value) 
     { 
      _property.SetValue(component, value); 
     } 

     public override bool ShouldSerializeValue(object component) 
     { 
      return _property.ShouldSerializeValue(component); 
     } 
    } 
} 

Comme vous pouvez le voir, il est parfaitement possible de faire une propriété en lecture seule pour un seul exemple:

 MyEntity a = new MyEntity { Foo = "hello", Bar = 42 }; 
     MyEntity b = new MyEntity { Foo = "world", Bar = 5 }; 
     EntityWrapper<MyEntity> wa = new EntityWrapper<MyEntity>(a); 
     EntityWrapper<MyEntity> wb = new EntityWrapper<MyEntity>(b); 

     var fooA = wa.GetProperties()["Foo"]; 
     var fooB = wb.GetProperties()["Foo"]; 

     wa.ReadOnly["Foo"] = false; 
     wb.ReadOnly["Foo"] = true; 

     Console.WriteLine("Property Foo of object a is read-only : {0}", fooA.IsReadOnly); 
     Console.WriteLine("Property Foo of object b is read-only : {0}", fooB.IsReadOnly);