One of the features inside Microsoft Orleans is the support for ‘Observers’. Through observers it becomes possible to send asynchronous notifications to one or more clients. It allows you to create a ‘simple’ distributed pub/sub mechanism.
I didn’t find the documentation very clear on this part, so here is a step by step guide on how to implement an Orleans observer:
Step 1 - Create the observer client
An observer is a one-way asynchronous interface that inherits from IGrainObserver, and all its methods must be void. So let’s create this interface first:
Inside our client we need to create a class that implements this interface:
Step 2 – Handling registrations
To handle the registrations we need a grain that can store the list of registered clients. Let’s create a grain interface that can handle the registrations. Let us also add a Publish() method that can be called to publish a message to all registered clients:
Next it’s time to implement the corresponding grain. Inside this grain we use another class to handle the registrations. In previous versions of Orleans you could use the built-in ObserverSubscriptionManager class, but in Orleans 2 and 3 you’ll have to create this class yourself.
Let’s do that first:
Now we can finally create our grain implementation which is rather simple as most of the work is done by the ObserverSubscriptionManager:
The work on the server side is done!
Step 3 - Link the client to the server
As a last step we need to link the observer client to our SubscriptionManagerGrain. Therefore the client needs to call a static method on the observer factory, CreateObjectReference(), to turn the class into a grain reference, which can then be passed to the subscription method on the notifying grain.
Let’s add an Init() method to do this:
We also add the possibility to unsubscribe and publish a message through the client: