Beobachten Sie ein Objektdiagramm für Änderungen

Question

Gibt es eine Möglichkeit, ein Objektdiagramm für Änderungen an einem Objekt zu beobachten und etwas basierend auf dieser Änderung zu tun?

Können sagen, ich habe folgendes:

public class Main:INotifyPropertyChanged 
{ 
    public ObservableCollection<Foo> FooItems { get; } 
    public ObservableCollection<Bar> BarItems { get; } 
} 

public class Foo:INotifyPropertyChanged 

public class Bar:INotifyPropertyChanged 
{ 
    public ObservableCollection<Other> OtherItems { get; } 
} 

public class Other:INotifyPropertyChanged 

Was wäre der beste Weg, eine Art von Änderung Benachrichtigungssystem über alle Objekte zu implementieren? Zum Beispiel eine automatische Speicherung, bei der jede Änderung das System veranlassen würde, die Klasse Main zu serialisieren.

Sollte ich einen Klebecode in der Main Klasse haben und die BarItems für Änderungen beobachten, dann an ihre PropertyChanged anschließen? Dies scheint ein bisschen chaotisch und fehleranfällig für mich. Gibt es einen besseren Weg?

Answer 1

Anstatt Objekte ihre eigene Eigenschaft Ereignisse geändert erhöhen, vielleicht könnte sie stattdessen ein gemeinsames Ereignis auslösen. Zum Beispiel:

public class SharedChangeNotifier 
{ 
    public static event EventHandler<DataChangedEventArgs> SharedChangeEvent; 

    protected void RaiseChangeEvent() 
    { 
     if (SharedChangeNotifier.SharedChangeEvent != null) 
     { 
      SharedChangeNotifier.SharedChangeEvent(
       this, new DataChangedEventArgs()); 
     } 
    } 
} 

public class Foo : SharedChangeNotifier 
{ 
    public int MyProperty 
    { 
     get { ... } 
     set 
     { 
      ... 
      RaiseChangeEvent(); 
     } 
    } 
} 

Sie könnten dann einen Ereignishandler auf den statischen SharedChangeNotifier des SharedChangeEvent befestigen benachrichtigt zu werden, sobald ein Objekt aus SharedChangeNotifier Ableitung geändert wird, wie folgt aus:

SharedChangeNotifier.SharedChangeEvent += (sender, args) => { 
    DoWhatever(); 
}; 

Answer 2

Ich las gerade eine interessante Blog-Post zu diesem Thema bei http://www.lennybacon.com/ReBlinderFleckChangeTracking.aspx

Der Beitrag ist in deutscher Sprache, aber wie es meistens Code ist, sollte es in Ordnung sein.

Hoffe, das hilft!

Answer 3

So wie ich es getan habe In der Vergangenheit wurde eine separate ChangeTracker-Klasse mit einer Methode zum Registrieren von Objekten erstellt. Verwenden Sie innerhalb dieser Methode reflection, um das registrierte Objekt zu untersuchen, und verknüpfen Sie Ereignisse in jeder seiner Eigenschaften, die INotifyPropertyChanged implementieren.

Sie können dann Methoden fügen den Change den Zustand zu befragen, zum Beispiel IsDirty() oder implementieren Sie sogar INotifyPropertyChanged für den ChangeTracker.

(Achten Sie darauf, IDisposable auf dem Change zu implementieren und zu verwenden, und legen Sie alle Event-Handler zu dieser Zeit).

Answer 4

Sie konnten die gleiche Prozedur für alle Elemente, die INotifyPropertyChanged Ereignisse implementieren:

foreach (INotifyPropertyChanged obj in FooItems) 
    obj.PropertyChanged+= this.modified; 

// likewise for bar items, and when items are added 

private void modified(object sender, EventArgs args) 
{ 
    this.Save(); 
} 

bearbeiten>, das gleiche zu tun, wenn ein Element hinzugefügt:

private void addToList<T>(ref List<T> l, T item) where T : INotifyPropertyChanged 
{ 
    item.PropertyChanged += this.modified; 
    l.Add(item); 
} 

nennen es mit:

Foo item = new Foo(); 
List<Foo> fooItems = new List<Foo>(); 

addToList<Foo>(ref fooItems, item);