What is dirty checking?
Dirty checking is simply a way to check an object to see if it contains changes. This can be used to prevent unnecessary database updates. Properly implemented it should also account for the object changing back to its original state.
For example:
We change the spelling of a dog’s name “Spottie” to “Spotty". If we were to test the object it should return dirty.
Then if we decide the original spelling was correct and change it back to “Spottie” the object should no longer return dirty.
How we implemented it:
We wanted to extend our LINQtoSQL generated classes to implement dirty checking. All we had to do was extend the OnLoaded() method to call our copy constructor so that we had a private copy of the original object. Then we can simply check that private object against the current object state property by property to determine if the object was dirty.
partial class Dog
{
private Dog _Original;
// Copy constructor.
public Dog(Dog previous)
{
Name = previous.Name;
Breed = previous.Breed;
Age = previous.Age;
Sex = previous.Sex;
Weight = previous.Weight;
Color = previous.Color;
}
//Here we copy the original object inside of itself for dirty checking
partial void OnLoaded()
{
_Original = new Dog(this);
}
//dirty checking using _Original from copy constructor
public bool IsDirty
{
get
{
return
!(
this.Name == _Original.Name &&
this.Breed == _Original.Breed &&
this.Age == _Original.Age &&
this.Sex == _Original.Sex &&
this.Weight == _Original.Weight &&
this.Color == _Original.Color
);
}
}
}
-ctrlShiftBryan