How to create Hot observable in reactive extension - oracle

Question

I am trying to use Reactive extensions with Oracle AQ. When a message comes on Oracle Queue, it fires a "OracleAQMessageAvailableEvent" which tells the consumer that there is a message. Inside the OracleAQMessageAvailableEventHandler the consumer calls OracleAQQueue.Dequeue() to retrieve the message.
I have got the above working with RX. Following is the code I have used.
var messages = Observable.FromEventPattern<OracleAQMessageAvailableEventHandler, OracleAQMessageAvailableEventArgs> (
h => _queue.MessageAvailable += h, h => _queue.MessageAvailable -= h)
.Where(x => x.EventArgs.AvailableMessages > 0)
.Select(x =>
{
OracleAQMessage msg = _queue.Dequeue();
return (UpdateMsg) msg.Payload;
});
messages.subscribe(....)
Problem is that if I subscribe to messages once everything works but if I subscribe to messages multiple times (i.e multiple consumers inside my application) then every consumer will try to call "_queue.Dequeue()" and every call after the first call will fail if we have no new message.
Could anyone please guide me what should I do. I think, my scenario is for Hot Observable but I am struggling to get my head around it.

Answer 1

I think you are correct that you are looking for a Hot Observable.
If we follow the code it may be more clear why you are seeing _queue.Dequeue(); being called multiple times.
First you subscribe to the event from Oracle
Observable.FromEventPattern<OracleAQMessageAvailableEventHandler, OracleAQMessageAvailableEventArgs> (
h => _queue.MessageAvailable += h,
h => _queue.MessageAvailable -= h)
This is just like hooking up an event handler as you would have in a pre-Rx world.
Everyone the listens (subscribes) will receive the same events.
If they subscribe after an event is raised, then they have missed it.
Then you filter out empty sets.
.Where(x => x.EventArgs.AvailableMessages > 0)
Nothing special there.
Then you perform a side effect from inside your query.
.Select(x =>
{
OracleAQMessage msg = _queue.Dequeue();
return (UpdateMsg) msg.Payload;
});
The side effect here is that you are making a destructive read (Dequeue).
All subscribers when they are pushed an event from the upstream _queue.MessageAvailable will all try to call Dequeue().
To avoid all of the subscribers to invoke the side effect, you can make the sequence Hot (as you suggested).
To do this you can look at the Publish() operator.
The Publish() operator will return you an IConnectableObservable<T> that just extends IObservable<T> by adding the Connect() method.
This allow fine grained control of when the subscription logic is executed.
However, this maybe too much control for you, and you will probably find that RefCount() to be just what you need.
Observable.FromEventPattern<OracleAQMessageAvailableEventHandler, OracleAQMessageAvailableEventArgs> (
h => _queue.MessageAvailable += h,
h => _queue.MessageAvailable -= h)
.Where(x => x.EventArgs.AvailableMessages > 0)
.Select(x =>
{
OracleAQMessage msg = _queue.Dequeue();
return (UpdateMsg) msg.Payload;
})
.Publish()
.Refcount();
Now each of your subscribers will receive the same message, and your Dequeue() side effect will only be invoked once per event (and only while there are subscribers).
Hot and Cold observable's are covered here

Answer 2

Lee Campbell, Sorry my bad. The solution you mentioned does work. Actually, I was using it incorrectly. I have a class call QueueWrapper which has a property called Messages. I had this implementation of Messages
public IObservable<UpdateMsg> Messages {
get { return Observable.FromEventPattern<OracleAQMessageAvailableEventHandler, OracleAQMessageAvailableEventArgs> (
h => _queue.MessageAvailable += h,
h => _queue.MessageAvailable -= h)
.Where(x => x.EventArgs.AvailableMessages > 0)
.Select(x =>
{
OracleAQMessage msg = _queue.Dequeue();
return (UpdateMsg) msg.Payload;
})
.Publish()
.Refcount();
}}
and my client code was subscribing using Messages property like this
// First Subscription
_queueWrapper.Messages.Subscribe(....)
// Second Subscription
_queueWrapper.Messages.Subscribe(....)
so for each subscription, Messages property was returning a new IObservable. To fix this, I moved the initialization of observable to the constructor of QueueWrapper i.e following code :
public QueueWrapper() {
_messages = Observable.FromEventPattern<OracleAQMessageAvailableEventHandler, OracleAQMessageAvailableEventArgs> (
h => _queue.MessageAvailable += h,
h => _queue.MessageAvailable -= h)
.Where(x => x.EventArgs.AvailableMessages > 0)
.Select(x =>
{
OracleAQMessage msg = _queue.Dequeue();
return (UpdateMsg) msg.Payload;
})
.Publish()
.Refcount();
}
and my Messages property just return _messages;
public IObservable<UpdateMsg> Messages { get { return _messages; } }
After that everything started working as expected.