DefineObserver for query with anonymous type in Streaminsight 2.1 using the Rx Framework

Question

Hello all,
Assuming one has the following observable:
var source =
myApp.DefineObservable(() => Observable.Interval(TimeSpan.FromSeconds(1)))
.ToPointStreamable(x => PointEvent.CreateInsert(DateTimeOffset.Now, x),
AdvanceTimeSettings.IncreasingStartTime);
One can write the following query:
var query = from integer in source.TumblingWindow(TimeSpan.FromSeconds(5))
select integer.Avg(e => e);
And bind it to the following observer:
var sink = myApp.DefineObserver(() => Observer.Create<double>(Console.WriteLine));
using (query.Bind(sink).Run("Query 1"))
Console.WriteLine("Running, press Enter to stop");
Console.ReadLine();
And everything works fine.
Now let's say I want to modify the query so it can return (for example) both the average and the number of elements in the tumbling window. In that case I would modify to query like this:
var query = from integer in source.TumblingWindow(TimeSpan.FromSeconds(5))
select new
Average = integer.Avg(e => e),
Count = integer.Count()
However, the sink is expecting a "double" not an anonymous type.
My question is, is it possible to define a sink that can accept an anonymous type, ie. is it possible to right something like this:
var sink = myApp.DefineObserver(() => Observer.Create<????????????????>
(x =>
Console.WriteLine("Average: {0} Count: {1}", x.Average,
x.Count));
or do I need to define a "AverageAndCount" class beforehand so I do something like:
var query = from integer in source.TumblingWindow(TimeSpan.FromSeconds(5))
select new AverageAndCount
Average = integer.Avg(e => e),
Count = integer.Count()
};var sink = myApp.DefineObserver(() => Observer.Create<AverageAndCount>
                                          (x =>
                                           Console.WriteLine("Average: {0} Count: {1}", x.Average,
                                                             x.Count));

Answer 1

No ... you don't. There are ways around it ... there's no problem that an additional layer of abstraction can't fix, right? What you need is a way to get the type of the payload in a way that the compiler can infer it.
From an upcoming blog post in my current series, here's an extension method that would do that with my "dual-mode sinks":
public static IRemoteStreamableBinding BindConsumer<TPayload>(
this IQStreamable<TPayload> stream,
Application cepApplication,
Type consumerFactoryType,
object configInfo,
EventShape eventShape)
var factory = Activator.CreateInstance(consumerFactoryType) as ISinkFactory;
if (factory == null)
throw new ArgumentException("Factory cannot be created or does not implement ISinkFactory");
switch (eventShape)
case EventShape.Interval:
var intervalObserver = cepApplication.DefineObserver(() => factory.CreateIntervalObserverSink<TPayload>(configInfo));
return stream.Bind(intervalObserver);
case EventShape.Edge:
var edgeObserver = cepApplication.DefineObserver(() => factory.CreateEdgeObserverSink<TPayload>(configInfo));
return stream.Bind(edgeObserver);
case EventShape.Point:
var pointObserver = cepApplication.DefineObserver(() => factory.CreatePointObserverSink<TPayload>(configInfo));
return stream.Bind(pointObserver);
default:
throw new ArgumentOutOfRangeException("eventShape");
Within the sink itself, you'll need to use reflection to "unpack" the event. It's not quite as straighforward - or as simple - as the untyped output adapter but it does work quite well. Keep an eye on my blog ... I should get an update posted this week that
will get you a good ways down the path. :-)
DevBiker (aka J Sawyer)
Microsoft MVP - Sql Server (StreamInsight)
If I answered your question, please mark as answer.
If my post was helpful, please mark as helpful.