Question

So I just fixed a bug in a framework I’m developing. The pseudo-pseudocode looks like this:

myoldObject = new MyObject { someValue = 'old value' }; cache.Insert('myObjectKey', myoldObject); myNewObject = cache.Get('myObjectKey'); myNewObject.someValue = 'new value'; if(myObject.someValue != cache.Get('myObjectKey').someValue)      myObject.SaveToDatabase(); 

So, essentially, I was getting an object from the cache, and then later on comparing the original object to the cached object to see if I need to save it to the database in case it’s changed. The problem arose because the original object is a reference…so changing someValue also changed the referenced cached object, so it’d never save back to the database. I fixed it by cloning the object off of the cached version, severing the reference and allowing me to compare the new object against the cached one.

My question is: is there a better way to do this, some pattern, that you could recommend? I can’t be the only person that’s done this before 🙂

Answer 1

Dirty tracking is the normal way to handle this, I think. Something like:

class MyObject {   public string SomeValue {       get { return _someValue; }      set {         if (value != SomeValue) {           IsDirty = true;           _someValue = value;        }   }    public bool IsDirty {      get;      private set;   }    void SaveToDatabase() {      base.SaveToDatabase();       IsDirty = false;   } }  myoldObject = new MyObject { someValue = 'old value' }; cache.Insert('myObjectKey', myoldObject); myNewObject = cache.Get('myObjectKey'); myNewObject.someValue = 'new value'; if(myNewObject.IsDirty)    myNewObject.SaveToDatabase();