如何根据每个元素的条件循环可观察序列？

Question

I have a sequence and i need to repeat it based on condition from each element. For example i need to reprocess an element if it's marked with a "failed" flag. My problem is i cannot find how to do the while-loop operation.

TakeWhile is almost what i need but it does not repeat itself.

/*
* The following lines are just an example to comprehend the idea
*/
var observableSequence = sequence.ToObservable();
observableSequence
    //This ´DoWhile´ did not worked because does not accept each element as argument
    //and sequence at this point is not the same as `observableSequence`
    .DoWhile(() => sequence.Any(item => !item.Failed))
    .Where(item => item.Failed == true) //OK here i could put another condition for limited retries...
    .Subscribe(item => {
        try{
            //Do stuff...
            //. . .
            item.Failed = false;
        } catch
        {
            item.Failed = true;
        }
    });

Answer 1

I'd suggest merging the original sequence with a new observable that you feed objects into as they fail.

var retries = new ReplaySubject<Foo>();
var loopSequence = sequence.ToObservable().Merge(retries);

loopSequence
    .Where(item => item.Failed)
    .Subscribe(item =>
    {
        try{
            //Do stuff
            item.Failed = false;
        } catch
        {
            item.Failed = true;
        }
        retries.OnNext(item);
    });

It's generally considered bad practice to change state of objects in observables, so you might want to consider creating transforms instead:

loopSequence
    .Where(item => item.Failed)
    .Subscribe(item =>
    {
        try{
            //Do stuff
            retries.OnNext(new Item { ..., Failed = false });
        } catch
        {
            retries.OnNext(new Item { ..., Failed = true });
        }
    });

You should also be really careful with this pattern, since a continually-failing item will put your program execution into a kind of infinite loop.

Answer 2

You can wrap each value and retry the operations independently:

observableSequence
  .SelectMany(item => 
    Observable.Return(item)
      .Select(x => //Do Stuff)
      //Optional argument, omitting retries infinitely until
      //success
      .Retry(3)
  )

  .Subscribe(item => {
    //Handle the results
  });

Optionally Return takes a IScheduler as its second argument which could change the order that retries get processed (recursive vs. trampoline).