How to check if an object has changed?

Question

I have an object, which contains other objects, which contain other objects, including lists, etcetera. This object is databound to a form, exposing numerous fields to the user in different tabs. I also use master-child datagridviews.

Any idea how to check if anything has changed in this object with respect to an earlier moment? Without (manually) adding a changed variable, which is set to true in all (>100) set methods.

Answer 1

As Sll stated, an dirty interface is definitely a good way to go. Taking it further, we want collections to be dirty, but we don't want to necessarily set ALL child objects as dirty. What we can do, however is combine the results of their dirty state, with our own dirty state. Because we're using interfaces, we're leaving it up to the objects to determine whether they are dirty or not.

My solution won't tell you what is dirty, just that the state of any object at any time is dirty or not.

public interface IDirty
{
    bool IsDirty { get; }
}   // eo interface IDirty


public class SomeObject : IDirty
{
    private string name_;
    private bool dirty_;

    public string Name
    {
        get { return name_; }
        set { name_ = value; dirty_ = true; }
    }
    public bool IsDirty { get { return dirty_; } }
}   // eo class SomeObject


public class SomeObjectWithChildren : IDirty
{
    private int averageGrades_;
    private bool dirty_;
    private List<IDirty> children_ = new List<IDirty>();

    public bool IsDirty
    {
        get
        {
            bool ret = dirty_;
            foreach (IDirty child in children_)
                dirty_ |= child.IsDirty;
            return ret;
        }
    }

}   // eo class SomeObjectWithChildren

Answer 2

You can implement INotifyPropertyChanged interface and if you user VS2010 there is addin that automatic alter all properties in IL (so you don't have to implement it manualy).

I belive there is also some other methods that use Weaving technique.

I found addin in vs2010 gallery:

http://visualstudiogallery.msdn.microsoft.com/bd351303-db8c-4771-9b22-5e51524fccd3

There is nice example - your code:

public class Person : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    public string GivenNames { get; set; }
}

What get compiled:

public class Person : INotifyPropertyChanged
{

    public event PropertyChangedEventHandler PropertyChanged;

    private string givenNames;
    public string GivenNames
    {
        get { return givenNames; }
        set
        {
            if (value != givenNames)
            {
                givenNames = value;
                OnPropertyChanged("GivenNames");
                OnPropertyChanged("FullName");
            }
        }
    }
}

This is from first resoult from unce G (might be usefull):

http://justinangel.net/AutomagicallyImplementingINotifyPropertyChanged

http://www.codeproject.com/KB/WPF/AutonotifyPropertyChange.aspx

Answer 3

How do you define "equality" (between old and new state)?

• Are you comparing properties only or fields as well?
• Are you only comparing public properties/fields?
• Do you ever ignore any properties/fields (i.e. their modifications do not matter)?
• How do you compare "atomic" types (e.g. are all string comparisons case-insensitive, or you need case-sensitive in some places as well).

If answers to these questions are general enough (i.e. you can devise a set of rules that apply to all of your objects), then you could theoretically accomplish what you want through reflection: The basic idea is to read all properties/fields of the "root" object, then store the "atomic" ones and recursively descend into the "non-atomic" ones (and repeat the whole process). Later, when you want to check if anything changed, you would repeat the recursive descent and compare the results with the stored values.

I'm not arguing this solution is particularly performant or even easy (you'd need to devise a robust naming convention for storing old values and be very careful about multi-threading), but it could potentially be general.

Answer 4

If you want the lazy and easy way of doing this, then @Burimi is correct in that you need to manage this within your class setters and getters.

You will have to, excuse the expression but, "old school" your class/object properties back to having a public getter and setter that accesses a private variable. Within the public setter, is where you would set your object's dirty flag, as well as your private variable... but you have to do it for every property that matters, one by one... I personally think this warrants one of these in the future:

public string FirstName { get; set => { this.isDirty=true; } }

Which would basically equate to the same as the current { get; set; } , but also, if either of these have a => next to it, it would equate to and run this code at after //getting or setting it but I don't even know if this is something that people would like to have or not nowadays.

public class myObject
{
    public bool isDirty { get; set; }
    private string FirstName_ = "";
    public string FirstName { get { return FirstName_; } set { FirstName_ = value; isDirty = true; } }
}

Now, any time FirstName_ is changed, the entire object becomes dirty... rinse repeat.

Of course if you also wanted to report up, as it happens, all you have to do is fire a notify event that you created yourself and has the data you need... here's an example of what I mean:

public class myObject
{
    public bool isDirty { get; set; }
    private string FirstName_ = "";
    public string FirstName { get { return FirstName_; } set { FirstName_ = value; isDirty = true; RaisePropertyChanged("FirstName"); } }

    #region use YOUR_OWN_NOTIFY_EventHandler

    public event YOUR_OWN_NOTIFY_EventHandler PropertyChanged;

    public void RaisePropertyChanged(string propertyName)
    {
        YOUR_OWN_NOTIFY_EventTHandler handler = PropertyChanged;
        if (handler != null) handler(new myPropertyChangedEventArgs(propertyName));
    }

    #endregion
}

Hope this helps someone...

Answer 5

You may override the GetHashCode and then create a hash code which is a mixture of the properties of the object. So your program will get the hashcode of the object, store it and then on next check, compare it with current hashcode.

A very simplistic approach:

internal class Foo
{
    public string Bar { get; set; }
    public int Baaz { get; set; }

    public override int GetHashCode()
    {
        return Bar.GetHashCode() - Baaz.GetHashCode();
    }
}

Be careful since you have to look for Bar not being null and also cater for integer overflows.

---

EDIT

After looking at Eirc Lippert's blog,

I do agree GetHashCode must not be used.

I keep the answer to keep the wealth of discussions.

Answer 6

Comparing Hash Codes over time might be an option. If you don't want to add that logic you could serialize the object twice and compare the hash codes of the two resulting strings.

EDIT to include some comments Have a look at this question/answer: Can serializing the same object produce different streams?

So be aware of a serializer that does **not ** guarantee the same output for the same object twice.

Answer 7

i can sugest something like this:

public class ObjectBase : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        protected virtual void OnPropertyChanged(string propertyName)
        {
            OnPropertyChanged(propertyName, true);
        }

        protected virtual void OnPropertyChanged(string propertyName, bool makeDirty)
        {
            if (PropertyChanged != null)
                PropertyChanged(this, new PropertyChangedEventArgs(propertyName));

            if (makeDirty)
                _IsDirty = true;
        }


        bool _IsDirty;

        public bool IsDirty
        {
            get { return _IsDirty; }
        }

    }

then in the property accesor you can

public class Vehicle : ObjectBase
{


  int _CarId;

 public int CarId
        {
            get { return _CarId; }
            set
            {
                if (_CarId != value)
                {
                    _CarId = value;
                    OnPropertyChanged(nameof(CarId));
                }

            }
        }
  }

hope it helps