Beim Verschachteln von Eigenschaften, die INotifyPropertyChanged implementieren, muss sich das übergeordnete Objekt anpassen.

Question

diese Frage wird meinen Mangel an Verständnis für das erwartete Verhalten zeigen, wenn die Umsetzung/mit INotifyPropertyChanged:

Die Frage ist - für die Bindung wie erwartet funktionieren, wenn Sie eine Klasse, die sich INotifyPropertyChanged implementiert, die verschachtelt hat Von Eigenschaften des Typs INotifyPropertyChanged wird erwartet, dass Sie die Änderungsbenachrichtigung für diese Eigenschaften intern abonnieren und dann die Benachrichtigungen weitergeben? Oder erwartet man von der verbindlichen Infrastruktur, dass die Smart-Software dies überflüssig macht?

Zum Beispiel (Code beachten Sie ist nicht vollständig - nur die Frage zu illustrieren gemeint):

public class Address : INotifyPropertyChanged 
    { 
     string m_street 
     string m_city; 

     public string Street 
     { 
      get { return m_street; } 
      set 
      { 
      m_street = value; 
      NotifyPropertyChanged(new PropertyChangedEventArgs("Street")); 
      } 
     } 

     public string City 
     { 
      get { return m_city; } 
      set 
      { 
      m_city = value; 
      NotifyPropertyChanged(new PropertyChangedEventArgs("City")); 
      } 
     } 

    public class Person : INotifyPropertyChanged 
    { 
     Address m_address; 

     public Address 
     { 
      get { return m_address = value; } 
      set 
      { 
      m_address = value; 
      NotifyPropertyChanged(new PropertyChangedEventArgs("Address")); 
      } 
     } 
    } 

Also, in diesem Beispiel hat wir ein verschachteltes Adressobjekt in einem Person-Objekt haben. Beide implementieren INotifyPropertyChanged, so dass die Änderung ihrer Eigenschaften zur Übertragung von Benachrichtigungen über die Änderung von Eigenschaften an Abonnenten führt.

Aber sagen wir mal mit Bindung jemand abonniert Änderungsbenachrichtigung für ein Person-Objekt und "lauscht" nach Änderungen an der Address-Eigenschaft. Sie erhalten Benachrichtigungen, wenn sich die Address-Eigenschaft selbst ändert (ein anderes Address-Objekt wird zugewiesen), erhalten jedoch KEINE Benachrichtigungen, wenn die vom verschachtelten Adressobjekt (Stadt oder Straße) enthaltenen Daten geändert werden.

Dies führt zu der Frage - ist die bindende Infrastruktur erwartet, damit umzugehen, oder sollte ich innerhalb meiner Implementierung von Person abonnieren Benachrichtigungen über das Adressobjekt und dann propagieren sie als Änderungen an "Adresse" abonnieren?

Wenn Sie an diesen Punkt kommen, danke, dass Sie sich die Zeit genommen haben, diese langatmige Frage zu lesen?

Kommentar sehr geschätzt!

Phil

Answer 1

Sie beantwortet diese Frage, wenn Sie

sagte

... sagen mit Bindung jemand Anmeldung Benachrichtigung auf ein Person-Objekt zu ändern,

, dass jemand Abonnieren von Person und hat keine Möglichkeit zu wissen, ob Adresse sich geändert hat. Sie müssen also selbständig mit dieser Situation umgehen (was sehr einfach zu implementieren ist).

Answer 2

Eine der einfachsten Möglichkeiten, es zu tun ist, um einen Ereignishandler zu Person hinzufügen, welche Benachrichtigungsereignisse aus m_address Objekt behandelt:

public class Person : INotifyPropertyChanged 
{ 
    Address m_address; 

    public Address 
    { 
     get { return m_address = value; } 
     set 
     { 
     m_address = value; 
     NotifyPropertyChanged(new PropertyChangedEventArgs("Address")); 
     m_address.PropertyChanged += new PropertyChangedEventHandler(AddressPropertyChanged); 
     } 
    } 
    void AddressPropertyChanged(object sender, PropertyChangedEventArgs e) 
    { 
     NotifyPropertyChanged(new PropertyChangedEventArgs("Address")) 
    } 
} 

Answer 3

Wenn Sie untergeordnete Objekte sehen wollen, als ob sie ein Teil sind Ein Elternteil direkt, Sie müssen selbst sprudeln.

Für Ihr Beispiel wären Sie in Ihrer Ansicht an "Address.Street" gebunden, daher müssen Sie einen Notifypropertychanged bubble, der diese Zeichenfolge enthält.

Ich schrieb einen einfachen Helfer, dies zu tun. Sie rufen einfach BubblePropertyChanged (x => x.BestFriend) in Ihrem übergeordneten Ansichtsmodellkonstruktor auf. n.b. Es gibt eine Annahme, dass Sie eine Methode namens NotifyPropertyChanged in Ihrem Parent haben, aber Sie können das anpassen, um zu passen.

 /// <summary> 
    /// Bubbles up property changed events from a child viewmodel that implements {INotifyPropertyChanged} to the parent keeping 
    /// the naming hierarchy in place. 
    /// This is useful for nested view models. 
    /// </summary> 
    /// <param name="property">Child property that is a viewmodel implementing INotifyPropertyChanged.</param> 
    /// <returns></returns> 
    public IDisposable BubblePropertyChanged(Expression<Func<INotifyPropertyChanged>> property) 
    { 
     // This step is relatively expensive but only called once during setup. 
     MemberExpression body = (MemberExpression)property.Body; 
     var prefix = body.Member.Name + "."; 

     INotifyPropertyChanged child = property.Compile().Invoke(); 

     PropertyChangedEventHandler handler = (sender, e) => 
     { 
      this.NotifyPropertyChanged(prefix + e.PropertyName); 
     }; 

     child.PropertyChanged += handler; 

     return Disposable.Create(() => { child.PropertyChanged -= handler; }); 
    } 

Answer 4

Eine alte Frage, doch ...

war meine ursprüngliche Ansatz Kind-Eigenschaft auf heften sich an die Eltern verändert. Dies hat einen Vorteil, das Essen des Elternteils ist einfach. Ich muss nur den Eltern abonnieren.

public class NotifyChangedBase : INotifyPropertyChanged 
{ 
    public event PropertyChangedEventHandler PropertyChanged; 
    readonly Dictionary<string, AttachedNotifyHandler> attachedHandlers = new Dictionary<string, AttachedNotifyHandler>(); 

    [NotifyPropertyChangedInvocator] 
    protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null) 
    { 
     PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName)); 
    } 

    protected void AttachPropertyChanged(INotifyPropertyChanged notifyPropertyChanged, 
     [CallerMemberName] string propertyName = null) 
    { 
     if (propertyName == null) throw new ArgumentNullException(nameof(propertyName)); 
     // ReSharper disable once ExplicitCallerInfoArgument 
     DetachCurrentPropertyChanged(propertyName); 
     if (notifyPropertyChanged != null) 
     { 
      attachedHandlers.Add(propertyName, new AttachedNotifyHandler(propertyName, this, notifyPropertyChanged)); 
     } 
    } 

    protected void DetachCurrentPropertyChanged([CallerMemberName] string propertyName = null) 
    { 
     if (propertyName == null) throw new ArgumentNullException(nameof(propertyName)); 
     AttachedNotifyHandler handler; 
     if (attachedHandlers.TryGetValue(propertyName, out handler)) 
     { 
      handler.Dispose(); 
      attachedHandlers.Remove(propertyName); 
     } 
    } 

    sealed class AttachedNotifyHandler : IDisposable 
    { 
     readonly string propertyName; 
     readonly NotifyChangedBase currentObject; 
     readonly INotifyPropertyChanged attachedObject; 

     public AttachedNotifyHandler(
      [NotNull] string propertyName, 
      [NotNull] NotifyChangedBase currentObject, 
      [NotNull] INotifyPropertyChanged attachedObject) 
     { 
      if (propertyName == null) throw new ArgumentNullException(nameof(propertyName)); 
      if (currentObject == null) throw new ArgumentNullException(nameof(currentObject)); 
      if (attachedObject == null) throw new ArgumentNullException(nameof(attachedObject)); 
      this.propertyName = propertyName; 
      this.currentObject = currentObject; 
      this.attachedObject = attachedObject; 

      attachedObject.PropertyChanged += TrackedObjectOnPropertyChanged; 
     } 

     public void Dispose() 
     { 
      attachedObject.PropertyChanged -= TrackedObjectOnPropertyChanged; 
     } 

     void TrackedObjectOnPropertyChanged(object sender, PropertyChangedEventArgs propertyChangedEventArgs) 
     { 
      currentObject.OnPropertyChanged(propertyName); 
     } 
    } 
} 

Die Verwendung ist einfach:

public class Foo : NotifyChangedBase 
{ 
    Bar bar; 

    public Bar Bar 
    { 
     get { return bar; } 
     set 
     { 
      if (Equals(value, bar)) return; 
      bar = value; 
      AttachPropertyChanged(bar); 
      OnPropertyChanged(); 
     } 
    } 
} 

public class Bar : NotifyChangedBase 
{ 
    string prop; 

    public string Prop 
    { 
     get { return prop; } 
     set 
     { 
      if (value == prop) return; 
      prop = value; 
      OnPropertyChanged(); 
     } 
    } 
} 

Doch dieser Ansatz nicht sehr flexibel ist und es gibt keine Kontrolle über sie, zumindest ohne zusätzliche komplexe Technik. Wenn das subskribierende System die Flexibilität hat, verschachtelte Datenstrukturen zu durchlaufen, ist seine Anwendbarkeit auf Kinder der ersten Ebene beschränkt.

Während die Einschränkungen akzeptabel sind, je nach Verwendung, habe ich seitdem von diesem Ansatz entfernt, wie es nie sicher ist, wie die Datenstruktur schließlich verwendet wird. Derzeit bevorzugen Lösungen wie diese:

https://github.com/buunguyen/notify

Auf diese Weise auch komplexe Datenstrukturen sind einfach und vorhersehbar, es ist teilnehmergesteuert, wie abonnieren und wie sie reagieren, spielt sie auch mit Fähigkeiten von Bindungsmotoren.