It seems to me that you are too insulting. I've written these "pipelined" classes before; all you need is a queue of workers, each with a wait descriptor that is signaled when the action completes.

public class Pipeline : IDisposable
{
    private readonly IEnumerable<Stage> stages;

    public Pipeline(IEnumerable<Action> actions)
    {
        if (actions == null)
            throw new ArgumentNullException("actions");
        stages = actions.Select(a => new Stage(a)).ToList();
    }

    public Pipeline(params Action[] actions)
        : this(actions as IEnumerable<Action>)
    {
    }

    public void Dispose()
    {
        foreach (Stage stage in stages)
            stage.Dispose();
    }

    public void Start()
    {
        foreach (Stage currentStage in stages)
            currentStage.Execute();
    }

    class Stage : IDisposable
    {
        private readonly Action action;
        private readonly EventWaitHandle readyEvent;

        public Stage(Action action)
        {
            this.action = action;
            this.readyEvent = new AutoResetEvent(true);
        }

        public void Dispose()
        {
            readyEvent.Close();
        }

        public void Execute()
        {
            readyEvent.WaitOne();
            action();
            readyEvent.Set();
        }
    }
}

      

        
        
        
      

    

And here's a test program that you can use to verify that the actions are always executed in the correct order and only one of the actions can be performed at once:

class Program
{
    static void Main(string[] args)
    {
        Action firstAction = GetTestAction(1);
        Action secondAction = GetTestAction(2);
        Action thirdAction = GetTestAction(3);
        Pipeline pipeline = new Pipeline(firstAction, secondAction, thirdAction);
        for (int i = 0; i < 10; i++)
        {
            ThreadPool.QueueUserWorkItem(s => pipeline.Start());
        }
    }

    static Action GetTestAction(int index)
    {
        return () =>
        {
            Console.WriteLine("Action started: {0}", index);
            Thread.Sleep(100);
            Console.WriteLine("Action finished: {0}", index);
        };
    }
}

      

        
        
        
      

    

Short, simple, completely thread safe.

If for some reason you need to start from a specific step in the chain, then you can simply add an overload for Start

:

public void Start(int index)
{
    foreach (Stage currentStage in stages.Skip(index + 1))
        currentStage.Execute();
}

      

        
        
        
      

    

Edit

Based on the comments, I think a few minor changes to the inner class Stage

should be enough to get the behavior you want. We just need to add the "queued" event in addition to the "ready" event.

    class Stage : IDisposable
    {
        private readonly Action action;
        private readonly EventWaitHandle readyEvent;
        private readonly EventWaitHandle queuedEvent;

        public Stage(Action action)
        {
            this.action = action;
            this.readyEvent = new AutoResetEvent(true);
            this.queuedEvent = new AutoResetEvent(true);
        }

        public void Dispose()
        {
            readyEvent.Close();
        }

        private bool CanExecute()
        {
            if (readyEvent.WaitOne(0, true))
                return true;
            if (!queuedEvent.WaitOne(0, true))
                return false;
            readyEvent.WaitOne();
            queuedEvent.Set();
            return true;
        }

        public bool Execute()
        {
            if (!CanExecute())
                return false;
            action();
            readyEvent.Set();
            return true;
        }
    }

      

        
        
        
      

    

Also change the pipeline method Start

to break if the stage cannot complete (i.e. already enqueued):

public void Start(int index)
{
    foreach (Stage currentStage in stages.Skip(index + 1))
        if (!currentStage.Execute())
            break;
}

      

        
        
        
      

    

The concept here is pretty simple, once again:

• The stage first tries to get the ready state immediately. If it succeeds, it starts up.
• If it cannot get the ready state (that is, the task has already started), it tries to get the state of the queue.
  • If it receives a state in the queue, it expects the ready state to become available and then releases the state in the queue.
  • If he cannot get the state in the queue, then he will refuse.

I read your question and comments again and I am sure this is exactly what you are trying to do and gives the best compromise between security, bandwidth and throttling.

Since ThreadPool

it can sometimes take a while for a response, you should delay the delay in the test program 1000

instead 100

if you really want to see the "gaps".