This approach is pretty much the accepted way to do anything in our company.
A simple example
- When a piece of data for a customer is requested from a service, we fetch all the data for that customer(relevant part to the service) and save it in a in-memory dictionary then serve it from there on following requests(we run singleton services).
- Any update goes to DB, then updates the in memory dictionary.
It seems all simple and harmless but as we implement more complicated business rules the cache gets out of sync and we have to deal with hard to find bugs.
Sometimes we defer writing to database, keeping new data in cache until then. There are cases when we store millions of rows in memory because the table has many relations to other tables and we need to show aggregate data quickly.
All this cache handling is a big part of our codebase and I sense this is not the right way to do it. All of this juggling adds too much noise to the code and it makes it hard to understand the actual business logic. However I don't think we can serve data in a reasonable amount of time if we have to hit the database every time.
I am unhappy about the current situation but I don't have a better alternative.
- My only solution would be to use NHibernate 2nd level cache but I have nearly no experience with it.
- I know many companies use Redis or MemCached heavily to gain performance but I have no idea how I would integrate them into our system.
- I also don't know if they can perform better than in-memory data structures and queries.
Are there any alternative approaches that I should look into?