3 разновидности событий:
- биржевой тик Ticked(price) - тек. рыночная цена
- заявка выполнена(полностю или частично) OrderMatched(order) 
- заявка снята OrderCanceled(order)

2 типа воздействий
- выставить заявку RegisterOrder(order)
- снять заявку CancelOrder(order)

// Статус заявки на покупку
    public enum OrderStatusEn
    {
        Matched, // Реализована  
        Cancelled // Снята
    }

    // Заявка на покупку
    public class Order
    {
        // Цена 
        public double Price;
        // Объем
        public int Volume;
        // Cтатус
        public OrderStatusEn Status;
    }

    // Интерфейс к торговой системе
    public interface ITrade
    {
        // Регистрация заявки на покупку.
        void RegisterOrder(Order order);
        // Снятие заявки на покупку.
        void CancelOrder(Order order);

        // АСИНХРОННАЯ ЧАСТЬ
        // Изменение статуса заявки
        event Action<Order> OrderChanged;
        // Новый биржевой "тик"
        event Action<double> NewTick;
    }

    public class Algorithm
    {
        // Состояние алгоритма
        private enum StateEn
        {
            // ничего не делаем, ожидаем события
            Idle,
            // покупка
            Buying,
            // снятие заявки на покупку
            CancellingBuy
        }

        // Состояние алгоритма.
        private StateEn state;

        // Текущий минимум цены на рынке.
        private double min;


        private ITrade trade;

        // Лимит - объем выставляемых заявок.
        private int limit;

        // текущая заявка на покупку.
        private Order order;


        public Algorithm(ITrade trade, int limit)
        {
            this.order = null;
            this.min = double.MaxValue;
            this.state = StateEn.Idle;
            this.trade = trade;
            this.trade.OrderChanged += new Action<Order>(orderChanged);
            this.trade.NewTick += new Action<double>(newTick);
            this.limit = limit;
        }

        private void orderChanged(Order order)
        {
            switch (order.Status)
            {
                case OrderStatusEn.Matched:
                    if (this.state == StateEn.Buying)
                        this.state = StateEn.Idle;
                    else if (this.state == StateEn.CancellingBuy) // пытались снять, но заявка успела реализоваться
                        buying();
                    break;
                case OrderStatusEn.Cancelled:
                    if (this.state == StateEn.CancellingBuy)
                        buying();
                    break;
            }
        }


        private void buying()
        {
            this.order = new Order() { Price = this.min, Volume = this.limit };
            this.trade.RegisterOrder(this.order);
            this.state = StateEn.Buying;
        }

        private void cancellingBuying()
        {
            this.trade.CancelOrder(this.order);
            this.state = StateEn.CancellingBuy;

        }

        private void newTick(double price)
        {
            if (price < this.min) // минимум изменился (появился)
            {
                this.min = price;
                if (this.state == StateEn.Idle)
                {
                    buying();
                }
                else if (this.state == StateEn.Buying)
                {
                    cancellingBuying();
                }
            }
        }

    }

public static IEnumerable<Step> OrderChecker(Context context, Getter<double> minPriceGetter)
{
   Order order = null;
   double currentMinPrice = minPriceGetter();
   while (context.IsRunning)
   {
      if (order != null)
      {
        // Асинхронное удаление заявки
        bool isDeleted = false;
        context.DeleteOrder(order, delegate() { isDeleted = true; } );
        yield return new WaitStep(delegate { return isDeleted; });
        order = null;
      }

      order = new Order(minPriceGetter());
      context.AddOrder(order);

      yield return new WaitStep(delegate
        {
           if (minPriceGetter() != currentMinPrice)
           {
             currentMinPrice = minPriceGetter();
             // Завершаем ожидание
             return true;
           }
           // Продолжаем ожидание
           return false;
        }); 
   }
}

public class Algorithm : IDisposable
{
    // Состояние алгоритма
    private enum StateEn
    {
        // ничего не делаем, ожидаем события
        Idle,
        // покупка
        Buying,
        // снятие заявки на покупку
        CancellingBuy
    }

    private class State
    {
        public State(Order order, StateEn state, double price)
        {
            Order = order;
            StateEn = state;
            Price = price;
        }

        public Order Order { get; private set; }
        public StateEn StateEn { get; private set; }
        public double Price { get; private set; }
    }


    private ITrade trade;

    // Лимит - объем выставляемых заявок.
    private int limit;

    IDisposable cookie;

    public Algorithm(ITrade trade, int limit)
    {
        this.trade = trade;
        this.limit = limit;

        //Последовательность состояний
        IConnectableObservable<State> states = null;
            
        //Создаем ленивость вычислений
        var deferedStates = Observable.Defer(() => states);

        //Используем Subject чтобы сделать из событий IObservable
        var orderChanged = new Subject<Order>();
        var ticks = new Subject<double>();
        this.trade.OrderChanged += o => orderChanged.OnNext(o);
        this.trade.NewTick += v => ticks.OnNext(v);

        //Последовательность минимальных цен
        var minPrices = ticks.Scan(double.MaxValue, (min, v) => min > v ? v : min).DistinctUntilChanged();

        //Разделяем потоки событий чтобы легче было писать
        var orderMatched = orderChanged.Where(o => o.Status == OrderStatusEn.Matched);
        var orderCancelled = orderChanged.Where(o => o.Status == OrderStatusEn.Cancelled);
        var idleState = deferedStates.Where(s => s.StateEn == StateEn.Idle);
        var buyState = deferedStates.Where(s => s.StateEn == StateEn.Buying);
        var cancellingState = deferedStates.Where(s => s.StateEn == StateEn.CancellingBuy);

        //Объединяем несколько результирующих потоков в один
        states = 
            Observable.Join(
                //Если новая минимальная цена и ожидаем события, то покупаем
                minPrices.And(idleState).Then((p, _) => Buy(p)),
                //Если новая минимальная цена и покупаем, то отменям
                minPrices.And(buyState)
                            .Then((p, s) =>
                            {
                                this.trade.CancelOrder(s.Order);
                                return new State(null, StateEn.CancellingBuy, p);
                            }),
                //Если статус заявки изменился на matched  и покупаем, то переходим в ожидание
                orderMatched.And(buyState).Then((o, s) => new State(null, StateEn.Idle, s.Price)),
                //Если статус заявки изменился и отменяем, то покупаем по новой цене 
                orderChanged.And(cancellingState).Then((_, s) => Buy(s.Price))
            ).Publish(new State(null, StateEn.Idle, 0));//Создается асинхронность
            

        cookie = states.Subscribe(s =>
            {
                //Получили забесплатно логирование в одном месте
#if DEBUG
                Console.WriteLine("{0} {1} {2}", DateTime.Now, s.StateEn, s.Price);
#endif
            });
        states.Connect();
    }


    private State Buy(double price)
    {
        var order = new Order() { Price = price, Volume = this.limit };
        this.trade.RegisterOrder(order);
        return new State(order, StateEn.Buying, price);
    }

    public void Dispose()
    {
        cookie.Dispose();
    }
}

class TradeAdapter
{
    ITrade trade;
    public TradeAdapter(ITrade trade)
    {
        this.trade = trade;

        var s = new Subject<double>();
        this.trade.NewTick += s.OnNext;
        Ticks = s;
    }

    public IObservable<OrderStatusEn> Buy(double price, int volume)
    {
        return Observable.CreateWithDisposable<OrderStatusEn>(obs =>
            {
                var order = new Order() { Price = price, Volume = volume };
                this.trade.RegisterOrder(order);

                var cancel = new CancellationDisposable();
                var isProcessed = false;

                Action<Order> changed = null;
                changed = o =>
                {
                    if (o == order)
                    {
                        isProcessed = true;
                        obs.OnNext(o.Status);
                        obs.OnCompleted();
                        this.trade.OrderChanged -= changed;
                    }
                };
                this.trade.OrderChanged += changed;

                cancel.Token.Register(() =>
                {
                    if (!isProcessed) trade.CancelOrder(order);
                });

                return cancel;
            });
    }

    public IObservable<double> Ticks { get; private set; }
}

public class Algorithm : IDisposable
{
    IDisposable cookie;

    public Algorithm(ITrade trade, int limit)
    {
        var adapter = new TradeAdapter(trade);
        var minPrices = adapter.Ticks.Scan(Math.Min).DistinctUntilChanged().Publish();
        var buyOnMinPrice = minPrices.SelectMany(p => adapter.Buy(p, limit).TakeUntil(minPrices));
        cookie = buyOnMinPrice.Subscribe();
        minPrices.Connect();
    }

    public void Dispose()
    {
        cookie.Dispose();
    }
}

IObservable<Data> Login(string login, string pwd)
{
    return from _ in LoginRemotely(login, pwd) //LoginRemotely возвращает IObservable<ЧТОНИТЬ>
           from d in LoadData(login) //LoadData возвращает IObservable<Data>
           select d;
}

public static IObservable<Unit> ReadExact(this Stream stream, byte[] buffer, int offset, int count)
{
    return ReadExactInternal(stream, buffer, offset, count).Concat().TakeLast(1).Select(_ => new Unit());
}
public static IEnumerable<IObservable<int>> ReadExactInternal(Stream stream, byte[] buffer, int offset, int count)
{
    var read = Observable.FromAsyncPattern<byte[], int, int, int>(stream.BeginRead, stream.EndRead);
    while(count>0)
    {
        int bytesRead = 0;
        yield return read(buffer, offset, count).Do(r => bytesRead = r);
        count -= bytesRead;
        offset += bytesRead;
    }
}

waitHandle.WaitOne(currentSleepTime.Value, false);

G>waitHandle.WaitOne(currentSleepTime.Value, false);
G>

Пока заявка не будет удалена новые изменения цены будут либо игнорироваться, либо складываться в очередь, в зависимости от того, что требуется по условию задачи.

G>IObservable<Data> Login(string login, string pwd)
G>{
G>    return from _ in LoginRemotely(login, pwd) //LoginRemotely возвращает IObservable<ЧТОНИТЬ>
G>           from d in LoadData(login) //LoadData возвращает IObservable<Data>
G>           select d;
G>}
G>

@inlineCallback
def login(self, login, pwd):
    success = yield loginRemotely(login, pwd)
    if success:
        self.data = yield loadData(login)

Как я понимаю задача у тебя примерно такая. Есть некий биржевой товар, у которого время от времени изменяется цена. При изменениях цены и выполнение определенных условий надо либо удалить старую заявку, либо поставить новую заявку, либо вначале удалить старую, а затем поставить новую заявку. Соответственно на каждый биржевой товар заводим Task, пока цена не меняется Task спит, как только поменялась, Task просыпает и проверяет условия — нужно ли удалять существующую заявку (если она есть) и нужно ли ставить новую заявку.

G>>IObservable<Data> Login(string login, string pwd)
G>>{
G>>    return from _ in LoginRemotely(login, pwd) //LoginRemotely возвращает IObservable<ЧТОНИТЬ>
G>>           from d in LoadData(login) //LoadData возвращает IObservable<Data>
G>>           select d;
G>>}
G>>

S>@inlineCallback
S>def login(self, login, pwd):
S>    success = yield loginRemotely(login, pwd)
S>    if success:
S>        self.data = yield loadData(login)

S>

IObservable<Data> Login(string login, string pwd)
{
    return from sucess in LoginRemotely(login, pwd) //LoginRemotely возвращает IObservable<bool>
           where sucess
           from d in LoadData(login) //LoadData возвращает IObservable<Data>
           select d;
}

G>>Ну оно имеет отношение к тому как ты её понял

public static void CopyTo(this Stream source, Stream dest, int bufferSize = 1024)
{
    var buffer = new byte[bufferSize];
    int bytesRead = 0;
    while((bytesRead = source.Read(buffer,0,bufferSize)) > 0)
    {
        dest.Write(buffer,0,bytesRead);
    }
}

G>public static void CopyTo(this Stream source, Stream dest, int bufferSize = 1024)
G>{
G>    var buffer = new byte[bufferSize];
G>    int bytesRead = 0;
G>    while((bytesRead = source.Read(buffer,0,bufferSize)) > 0)
G>    {
G>        dest.Write(buffer,0,bytesRead);
G>    }
G>}
G>

public static IEnumerable<Step>(this Stream source, Stream dest, int bufferSize)
{
   byte[] buffer = new byte[bufferSize];
   int bytesRead = 0;
   while((bytesRead = source.Read(buffer, 0, bufferSize)) > 0)
   {
     dest.Write(buffer, 0, bytesRead);
     yield return new WaitStep(TimeSpan.Zero);
   }
   yield return new FinishStep(true);
}

class ServiceStep : WaitStep
{
  public ServiceStep() : base(TimeSpan.Zero) {}
  public void SetServiceInfo(LabeledThread thread, Task task);
  public void ForceTask()
  {
    thread.ForceTask(task);
  }
}

IEnumerable<Step> TicketChecker(Context context, Ticket ticket)
{
  ServiceStep serviceStep = new ServiceStep();
  yield return serviceStep;

  double currentPrice = ticket.CurrentPrice;
  double newPrice = currentPrice;
  ticket.PriceChanged += delegate(double price)
  {
    newPrice = price;
    serviceStep.ForceTask();
  }

  while(context.IsRunning)
  {
    // Создание, удаление заявок и прочая бизнес-логика

    yield return new WaitStep(TimeSpan.FromMinutes(1), delegate { return newPrice != currentPrice || !context.IsRunning; });
  }
}

    public enum OrderStatus
    {
        Sent,
        Matched,
        Canceled
    }

    class Order
    {
        public double Price;
        public int Volume;
        public OrderStatus Status;
    }
        
    class Trader
    {
        
        public IObservable<double> Ticks {get; private set; }
        public IObservable<Order> OrderChanged { get; private set; }

        private Action<Order> orderChanged;

        public Trader()
        {
            var rnd = new Random();
            this.Ticks = Observable.Defer(
                () => Observable.Return(Math.Round(1500.0 + rnd.NextDouble() * 10, 2)))
                //.Delay(TimeSpan.FromMilliSeconds(100 * rnd.NextDouble())))
        .Repeat();

            var subj = new Subject<Order>();
            orderChanged += subj.OnNext;

            this.OrderChanged = Observable.Defer(() => subj);
            //this.OrderChanged = Observable.Defer(() => subj).Throttle(TimeSpan.FromMilliseconds(500 * rnd.NextDouble()));
        }

        public void RegisterOrder(Order order)
        {
            order.Status = OrderStatus.Matched;
            orderChanged(order);
        }

        public void CancelOrder(Order order)
        {
            order.Status = OrderStatus.Canceled;
            orderChanged(order);
        }      
    }

    class Program
    {
        static void Main(string[] args)
        {
            var trader = new Trader();
            using (trader.Ticks.Subscribe(
            tick => 
            {
                Console.WriteLine("Tick:" +  tick);
                if (tick > 1505) 
                    trader.RegisterOrder(new Order()); 
            },
            ex => Console.WriteLine(ex),
            () => Console.WriteLine("Completed")
            ))
            {
            }

            using (trader.OrderChanged.Subscribe(
                        order =>
                        {
                            Console.WriteLine("OrderChanged:", order.Status);
                        },
                        ex => Console.WriteLine(ex),
                        () => Console.WriteLine("Completed")
                        ))
            {
            }

            Console.ReadKey();
        }
    }

S>using (trader.Ticks.Subscribe(...))
S>{
S>}

    public class Order
    {
        public int Id;
        public double Price;
        public int Volume;
        public int RealizedVolume;
        public OrderStatus Status;

        public override string ToString()
        {
            return string.Format("Order Id={0} Status={1}", Id, Status);
        }
    }