Calling 2 httpwebrequests in parallel using Reactive Extensions - httpwebrequest

Question

i m trying to call 2 httpwebrequest in parallel and make them call the same callback when they are done using Rx extensions.
But i don0t know how i can achive this..here's my code:
private static IObservable<Stream> GetImage(string path)
{
var uri = new Uri(path);
var thumburi = new Uri(path + "_thumb.jpg");
return Observable.Create<Stream>(o =>
{
var request = (HttpWebRequest) HttpWebRequest.Create(uri);
var readComplete =
Observable.FromAsyncPattern<WebResponse>(
request.BeginGetResponse,
request.EndGetResponse)();
var subscription = readComplete
.Select(e => e.GetResponseStream())
.Subscribe(o);
return subscription;
});
}

Answer 1

With the latest bits and .Net 4.5, you could do something like this:
private static IObservable<byte[]> GetImages(string path)
{
var sources = new Uri[]
{
var uri = new Uri(path),
var thumburi = new Uri(path + "_thumb.jpg")
};
var obs = from uri in sources.ToObservable()
from data in Observable.Using(
() => new WebClient(),
client => client.DownloadDataTaskAsync(uri).ToObservable())
select data;
return obs;
}
I do wonder if you really want to just return steams of data and not care which stream corresponds to the base and which is the thumbnail. Once you make the request in parallel, you no longer control the order that they come back in. You could project a type that includes the uri and data stream to disambiguate them if you want.

Answer 2

I'm guessing you would pull out the asynchronous calls to two separate streams then concatenate them, no? Like this: http://leecampbell.blogspot.com/2010/06/rx-part-5-combining-multiple.html

Answer 3

I'd suggest this kind of solution.
Make GetImage more general purpose:
private static IObservable<Stream> GetImage(Uri uri)
{
return Observable.Create<Stream>(o =>
{
var request = (HttpWebRequest)HttpWebRequest.Create(uri);
var readComplete =
Observable.FromAsyncPattern<WebResponse>(
request.BeginGetResponse,
request.EndGetResponse)();
var subscription =
readComplete
.Select(e => e.GetResponseStream())
.Subscribe(o);
return subscription;
});
}
Then add a specific GetImages method that does the querying for the image and its thumb:
private static IObservable<Tuple<Uri, Stream>> GetImages(string path)
{
var uris = new []
{
new Uri(path + ".jpg"),
new Uri(path + "_thumb.jpg"),
}.ToObservable();
return
from uri in uris
from stream in GetImage(uri)
select Tuple.Create(uri, stream);
}
I've assumed that your path variable cannot contain the ".jpg" extension otherwise you'd have had to done some string manipulation.
Now GetImages returns a IObservable<Tuple<Uri, Stream>> because the SelectMany doesn't guarantee the return order of the streams so we need to use the Uri to disambiguate the streams.
Let me know if this works for you.

Answer 4

Why not just use Zip?
GetStream("foo.jpg").Zip(GetStream("bar.jpg"), (foo, bar) => new { foo, bar })
.Subscribe(fooAndBar => ...);