INotifyPropertyChangedを実装するネストプロパティは、親オブジェクトのpropogateを変更する必要がありますか？

Question

この質問は、実装時に/ INotifyPropertyChangedの使用期待されるふるまいの理解の私の欠如を示すことが起こっている：

質問です - あなたは自身がINotifyPropertyChangedのを実装するクラスを持っている場合、入れ子にしたこと、期待通りに動作するように結合するためにINotifyPropertyChanged型のプロパティは、これらのプロパティの通知を変更するために内部的にサブスクライブし、通知をプロポーザルする予定ですか？あるいは、拘束力のあるインフラストラクチャーにこれを不要にする賢明さが期待されていますか？例えば

（このコードは完全ではありません注意してください - ちょうど質問を説明するためのもの）：

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

ので、この例では、我々は、PersonオブジェクトにネストされたAddressオブジェクトを持っています。いずれもINotifyPropertyChangedを実装しているため、プロパティの変更によってプロパティ変更通知がサブスクライバに送信されます。

バインドを使用すると、Personオブジェクトの通知を変更するサブスクリプションを使用していて、Addressプロパティの変更を「リッスン」しているとします。 Addressプロパティ自体が変更された場合（別のAddressオブジェクトが割り当てられている場合）、ネストされたアドレスオブジェクト（都市または通り）に含まれるデータが変更された場合、通知を受け取らないことになります。

これは、これを処理することが期待されるバインディングインフラストラクチャか、Personの実装でアドレスオブジェクトの通知を変更して「アドレス」の変更として伝播する必要がありますかという疑問があります。

この点をお持ちの場合は、この長い質問を読んでいただきありがとうございます。

コメントありがとうございました！あなたが...誰かが

されていることを、誰かが が Personオブジェクトに通知を変更するためにサブスクライブされたバインディングを使用言う

を言ったとき

フィル

Answer 1

あなたはこの質問に答えPersonに加入し、Addressが変更されたかどうかを知る方法がありません。 あなたはこの状況を自分で処理しなければなりません（これは実装が簡単です）。

Answer 2

それを行うための最も簡単な方法の一つはm_addressオブジェクトからの通知イベントを処理する人にイベントハンドラを追加することです：彼らはの一部であるかのようにあなたが子供にしたい場合は

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

は見にオブジェクト彼らの親はあなた自身をバブリングする必要があります。

たとえば、ビュー内で 'Address.Street'にバインドするので、その文字列を含むnotifypropertychangedをバブリングする必要があります。

私はこれを簡単に手助けしました。親ビューモデルのコンストラクタでBubblePropertyChanged（x => x.BestFriend）を呼び出すだけです。 n.b.あなたの親にはNotifyPropertyChangedというメソッドがあると仮定していますが、それを適合させることができます。

 /// <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

古い質問が、それにもかかわらず...

私の独創的なアプローチは、親に変更された子プロパティを添付しました。これには利点があり、親のイベントを消費するのは簡単です。親に申し込むだけです。

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

使い方は簡単です：

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

しかし、このアプローチは非常に柔軟ではなく、それに対する制御は、少なくとも追加の複雑なエンジニアリングなしに、ありません。サブスクライブするシステムにネストされたデータ構造をトラバースする柔軟性がある場合、その適用範囲は第1レベルの子に限定されます。

使用方法に応じて警告が受け入れられるかもしれませんが、データ構造が最終的にどのように使用されるのかは決してわからないので、私はこのアプローチから離れました。現在、この1などのソリューションを好む：

https://github.com/buunguyen/notify

方法にも複雑なデータ構造がシンプルかつ予測可能であることを、それが結合エンジンの機能とよく果たしている、サブスクライブするとどのように反応するか、加入者の制御下にあります。