Often you want to do some "fix" on your data before pushing it to the database. Typically it's some auditty thingie --
UpdatedOn kind of stuff. After spreading it all around your application, you finally decide you should keep these things in one place.
If you, like me, is an NHibernate user, most likely you find advice to use a custom IInterceptor or IPreUpdateEventListener. Both are quite ugly solutions, since you have to manipulate the raw state values that are already read from the entity and are ready to be saved to the database. What's even worse, in the latter case you should sync it manually with the entity properties as well. One may think that the original code had been ported from Hibernate before
IDictionary was invented (I do understand that there might be some excuses, like performance considerations for example). Find the index of the required field in one array, then fix the value at the corresponding index in another one. Oh joy!
So, it's quite understandable that I wanted a more elegant solution. Just "fix" the entity before being saved, and also do it in a more, well, object oriented fashion. Naturally this should happen just before the property values are read.
So, I put a breakpoint on a property getter and started the debugger. Turned out the property was read by an instance of
NHibernate.Event.Default.DefaultFlushEntityEventListener, which leads me to believe that its
OnFlushEntity method is what actually turns my properties into arrays of raw values. Further investigation showed that this listener is an element of an array of
IFlushEntityEventListener-s. So, my plan (which, unsurprisingly, succeeded), was to put my custom implementation in this array before the default one.
Just show us the code! I hear you say. Ok, ok, I'm coming to that. Suppose you have a base entity class (but you're not quite sure, 'cause there might be some 3rd party entities floating around). You just add a template method to it called
PerformAudit, whatever. Here is my custom listener:
public class CustomFlushEntityEventListener : IFlushEntityEventListener
public void OnFlushEntity(FlushEntityEvent @event)
var entity = @event.Entity as EntityBase;
if (entity != null)
Now you have your class, here is how to tell NHibernate it should use it (during application startup):
configuration" is an instance of
NHibernate.Cfg.Configuration, and the code should be run before you build you
SessionFactory. The result is, for each entity being flushed, its
EnsureConsistency method is being called. The entity itself knows what to do (if anything) in this case. Audit, denormalization, whatever.
Now I do feel like a real Pro. Please tell me I am.