C# - Ermitteln, ob die Liste <T> verschmutzt ist?

Question

Ich bin Serialisierung Listen von Klassen, die meine Datenentitäten sind. Ich habe einen DataProvider, der eine Liste enthält.

Ich modifiziere immer Elemente direkt in der Sammlung.

Wie kann man am besten feststellen, ob sich Elemente in der Liste geändert haben? Ich benutze das Compact Framework.

Meine einzige aktuelle Idee ist es, einen Hash der Liste zu erstellen (wenn das möglich ist), wenn ich die Liste lade. Dann, wenn ich einen Speichervorgang mache, erhalte ich den Hash der Liste und sehe, ob sie unterschiedliche Werte haben. Wenn sie anders sind, speichere ich und speichere den gespeicherten Hash später zum Vergleich, wenn sie gleich sind, dann speichere ich nicht.

Irgendwelche Ideen?

Answer 1

Wenn die Elemente, die Sie der Liste hinzufügen, die Schnittstelle INotifyPropertyChanged implementieren, können Sie Ihre eigene generische Liste erstellen, die das Ereignis in dieser Schnittstelle für alle Objekte anhängt, die Sie der Liste hinzufügen, und das Ereignis aufhebt, wenn die Elemente entfernt werden Die Liste.

Es gibt eine BindingList<T> Klasse im Framework, die Sie verwenden können, oder Sie können Ihre eigenen schreiben.

Hier ist ein Beispiel add-Methode, vorausgesetzt, der Typ mit where T: INotifyPropertyChanged erklärt wurde:

public void Add(T item) 
{ 
    // null-check omitted for simplicity 
    item.PropertyChanged += ItemPropertyChanged; 
    _List.Add(item); 
} 

und die this[index] Indexer Eigenschaft:

public T this[Int32 index] 
{ 
    get { return _List[index]; } 
    set { 
     T oldItem = _List[index]; 
     _List[index] = value; 
     if (oldItem != value) 
     { 
      if (oldItem != null) 
       oldItem.PropertyChanged -= ItemPropertyChanged; 
      if (value != null) 
       value.PropertyChanged += ItemPropertyChanged; 
     } 
    } 
} 

Wenn Ihre Einzelteile nicht unterstützt INotifyPropertyChanged, aber sie In deinen Klassen würde ich darüber nachdenken, diese Unterstützung hinzuzufügen.

Answer 2

Sie könnten Ihre eigene IList<T>-Klasse erstellen, z. B. DirtyList<T>, die aufzeichnen kann, wenn sich die Liste geändert hat.

Answer 3

Sie könnten Ihre eigene Liste implementieren, die 2 interne Listen verwaltet ... und instanziierte Version und Tracking-Version ... z.

//Rough Psuedo Code 
public class TrackedList<T> : List<T> 
{ 
    public bool StartTracking {get; set; } 
    private List<T> InitialList { get; set; } 

    CTOR 
    { 
     //Instantiate Both Lists... 
    } 

    ADD(item) 
    { 
     if(!StartTracking) 
     { 
      Base.Add(item); 
      InitialList.Add(item); 
     } 
     else 
     { 
      Base.Add(item); 
     } 
    } 

    public bool IsDirty 
    { 
     get 
     { 
      Check if theres any differences between initial list and self. 
     } 
    } 
} 

Answer 4

Wenn Sie bereit sind, Reflexion zu verwenden, die List<T> Klasse verfügt über ein eigenes Feld _version genannt, die jedes Mal die Liste Änderungen erhöht. Es wird Ihnen nicht sagen, welche Elemente geändert wurden, aber Sie können es mit dem ursprünglichen Wert _version vergleichen, um eine unmodifizierte Liste zu erkennen.

Als Referenz wird dieses Feld verwendet, um sicherzustellen, dass Enumeratoren ungültig werden, wenn die Liste geändert wird. Sie sollten es also ziemlich zuverlässig für Ihre Zwecke verwenden können, es sei denn, der tatsächlich verwaltete Code für List<T> ändert sich.

Um den Wert von _version erhalten Sie so etwas wie diese verwenden:

List<T> myList; 
var field = myList.GetType().GetField("_version", BindingFlags.Instance | BindingFlags.NonPublic); 
int version = field.GetValue(myList); 

Allgemein gesprochen, obwohl dies nicht der beste Ansatz ist. Wenn Sie mit einem List<T> stecken, den jemand anderes erstellt hat, ist es wahrscheinlich die beste Option, die Sie haben. Beachten Sie, dass Änderungen am .NET-Framework den Namen des Felds ändern (oder vollständig entfernen) können. Es ist nicht garantiert, dass es in CLR-Implementierungen von Drittanbietern wie Mono vorhanden ist.

Answer 5

Stellen Sie sicher, dass T ein Nachkomme eines Objekts mit einem schmutzigen Flag ist und dass die IList-Implementierung eine Überprüfung auf das aufweist, was die schmutzigen Flags der Liste durchläuft.

Answer 6

Wie wäre es mit so etwas?

public class ItemChangedArgs<T> : EventArgs 
{ 
    public int Index { get; set; } 
    public T Item { get; set; } 
} 

public class EventList<T> : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable 
{ 
    private List<T> m_list; 
    public event EventHandler<ItemChangedArgs<T>> ItemAdded; 
    public event EventHandler<ItemChangedArgs<T>> ItemRemoved; 
    public event EventHandler<ItemChangedArgs<T>> ItemChanged; 
    public event EventHandler ListCleared; 

    public EventList(IEnumerable<T> collection) 
    { 
     m_list = new List<T>(collection); 
    } 

    public EventList(int capacity) 
    { 
     m_list = new List<T>(capacity); 
    } 

    public EventList() 
    { 
     m_list = new List<T>(); 
    } 

    public void Add(T item) 
    { 
     Add(item, true); 
    } 

    public void Add(T item, Boolean raiseEvent) 
    { 
     m_list.Add(item); 
     if (raiseEvent) RaiseItemAdded(this.Count - 1, item); 
    } 

    public void AddRange(IEnumerable<T> collection) 
    { 
     foreach (T t in collection) 
     { 
      m_list.Add(t); 
     } 
    } 

    private void RaiseItemAdded(int index, T item) 
    { 
     if (ItemAdded == null) return; 

     ItemAdded(this, new ItemChangedArgs<T> { Index = index, Item = item }); 
    } 

    public int IndexOf(T item) 
    { 
     return m_list.IndexOf(item); 
    } 

    public void Insert(int index, T item) 
    { 
     m_list.Insert(index, item); 
     RaiseItemAdded(index, item); 
    } 

    public void RemoveAt(int index) 
    { 
     T item = m_list[index]; 
     m_list.RemoveAt(index); 
     RaiseItemRemoved(index, item); 
    } 

    private void RaiseItemRemoved(int index, T item) 
    { 
     if(ItemRemoved == null) return; 
     ItemRemoved(this, new ItemChangedArgs<T> { Index = index, Item = item }); 
    } 

    public T this[int index] 
    { 
     get { return m_list[index]; } 
     set 
     { 
      m_list[index] = value; 
      RaiseItemChanged(index, m_list[index]); 
     } 
    } 

    private void RaiseItemChanged(int index, T item) 
    { 
     if(ItemChanged == null) return; 
     ItemChanged(this, new ItemChangedArgs<T> { Index = index, Item = item }); 
    } 

    public void Clear() 
    { 
     m_list.Clear(); 
     RaiseListCleared(); 
    } 

    private void RaiseListCleared() 
    { 
     if(ListCleared == null) return; 
     ListCleared(this, null); 
    } 

    public bool Contains(T item) 
    { 
     return m_list.Contains(item); 
    } 

    public void CopyTo(T[] array, int arrayIndex) 
    { 
     m_list.CopyTo(array, arrayIndex); 
    } 

    public int Count 
    { 
     get { return m_list.Count; } 
    } 

    public bool IsReadOnly 
    { 
     get { return false; } 
    } 

    public bool Remove(T item) 
    { 
     for (int i = 0; i < m_list.Count; i++) 
     { 
      if(item.Equals(m_list[i])) 
      { 
       T value = m_list[i]; 
       m_list.RemoveAt(i); 
       RaiseItemRemoved(i, value); 
       return true; 
      } 
     } 
     return false; 
    } 

    public IEnumerator<T> GetEnumerator() 
    { 
     return m_list.GetEnumerator(); 
    } 

    IEnumerator IEnumerable.GetEnumerator() 
    { 
     return m_list.GetEnumerator(); 
    } 
} 

Answer 7

Unter der Annahme, dass GetHashCode() für jedes Mitglied in der Liste enthalten sind ordnungsgemäß umgesetzt wird (und damit ändert sich, wenn ein Element ändert) ich etwas entlang der Linien von sich vorstellen:

public class DirtyList<T> : List<T> { 
    private IList<int> hashCodes = new List<int> hashCodes(); 
    public DirtyList() : base() { } 
    public DirtyList(IEnumerable<T> items) : base() { 
     foreach(T item in items){ 
      this.Add(item); //Add it to the collection 
      hashCodes.Add(item.GetHashCode()); 
     } 
    } 

    public override void Add(T item){ 
     base.Add(item); 
     hashCodes.Add(item); 
    } 
    //Add more logic for the setter and also handle the case where items are removed and indexes change and etc, also what happens in case of null values? 

    public bool IsDirty { 
     get { 
      for(int i = 0; i < Count: i++){ 
       if(hashCodes[i] != this[i].GetHashCode()){ return true; } 
      } 
      return false; 
     } 
    } 
} 

* Bitte Seien Sie sich bewusst, dass ich dies auf SO getippt habe und keinen Compiler habe, so dass der oben genannte Code in keiner Weise garantiert funktioniert, aber hoffentlich wird er die Idee zeigen.