I discovered the Orleans Smart Cache Pattern by listening to a talk by John Azariah and Sergey Bykov. The idea is that you can use Orleans as a distributed cache in front of (permanent) storage. This is really ideal if you have a read heavy system, which most are. You could optionally also choose to buffer your writes when you make state changes. Ultimately you will reduce load on your storage by accessing data/state from memory.
Blog Post Series:
- Part 1 – Practical Orleans
- Part 2 – Grains and Silos
- Part 3 – Smart Cache Pattern
- Part 4 – Event Sourced Grain
- Part 5 – EventStore for Grain Persistence
Video Tutorial
State Holder Grain
The idea is we are going to create a Grain that will be used for holding/containing our state. There are just two methods, setting and getting our state as defined in IStateHolderGrain<T>
Implementation
For this example, I’m creating a POCO CustomerState to hold some customer data.
Then create a ICustomerGrain that just extends IStateHolderGrain where T is our POCO CustomerState.
Our concrete class CustomerGrain that implements that new ICustomerGrain.
Lastly I created a CustomerStateService which just contains some static methods that create and retrieve our POCO.
Usage
As per my previous post, I’m using ASP.NET Core with Botwin Middleware for a route endpoint. From here I can use the CustomerStateService to create and fetch out our data.
Abstraction
One of the benefits is abstraction as we can have a POCO for our state that can be persisted to permanent storage. There’s no dependency of Orleans in our POCO or Botwin Module.
Also we have an immediate consistent cache. If we were to expose methods to modify the state, our grain would persist those to permanent storage when it decides and we are always returning the most up to date state.
More!
If you want to try the demo, all the source is available on my PracticalOrleans GitHub Repo.
Do you have any questions or comments? Are you using Orleans? I’d love to hear about it in the comments or on Twitter.