Convert IEnumerable <T> to IObservable <T> with maximum parallelism value

Question

I have an async task sequence (e.g. fetching N web pages). Now I want to expose them as IObservable<T>. My current solution uses the answer to this question :

async Task<ResultObj> GetPage(string page) {
    Console.WriteLine("Before");
    var result = await FetchFromInternet(page);
    Console.WriteLine("After");
    return result;
}

// pages is an IEnumerable<string>
IObservable<ResultObj> resultObservable =pages.Select(GetPage).
                 Select(t => Observable.FromAsync(() => t)).Merge();

// Now consume the list
foreach(ResultObj obj in resultObservable.ToEnumerable()) {
    Console.WriteLine(obj.ToString());
}

The problem is that I do not know how many pages to extract, and it can be large. I do not want to make hundreds of simultaneous requests. Therefore, I want to limit the maximum number of tasks that will be performed in parallel. Is there a way to limit the number of simultaneous calls GetPage?

Merge, maxConcurrent, concurrency invokation. "" "".

. IEnumerable<T>. , , .

Answer 1

. .

var resultObservable = pages
  .Select(p => Observable.FromAsync(() => GetPage(p)))
  .Merge(maxConcurrent);

, ,

• FromAsync , Func , . , , .

• Merge n .

, : - (2), GetPage Merge, , .

, : , (1) , GetPage , Merge , n . n .