Async/await и свой поток, как это сделать правильно?

    public class Worker
    {
        Queue<Helper> tasks = new Queue<Helper>(); 
 
        public Task Execute(Action action)
        {
            Helper h = new Helper(action);
 
            return Task.Run(() =>
            {
                tasks.Enqueue(h);
                h.WaitCompleted();
            });
        }
 
        public void Start()
        {
            ThreadPool.QueueUserWorkItem(WorkerThread);
        }
 
        private void WorkerThread(object state)
        {
            while (true)
            {
                if (tasks.Count > 0)
                {
                    var task = tasks.Dequeue();
 
                    try
                    {
                        task.Execute();
                    }
                    finally
                    {
                        task.Complete();
                    }
                }
                else
                {
                    Thread.Sleep(250);
                }
            }
        }
 
        private class Helper
        {
            ManualResetEvent waitHandle = new ManualResetEvent(false);
            private readonly Action action;
 
            public Helper(Action action)
            {
                this.action = action;
            }
 
            public void Execute()
            {
                action();
            }
 
            public void WaitCompleted()
            {
                waitHandle.WaitOne();
            }
 
            public void Complete()
            {
                waitHandle.Set();
            }
        }
 
    }

  public abstract class TaskQueue : IDisposable
  {
    private readonly object syncObject = new object();
    private readonly Queue<Action> commands = new Queue<Action>();
    private volatile bool inProcess;
 
    private static readonly TimeSpan disposeEventTimeout = TimeSpan.FromSeconds(10);
    private readonly ManualResetEvent disposeEvent = new ManualResetEvent(true);
    private bool disposed;
 
    public void Enqueue(Action action)
    {
      lock (syncObject)
      {
        commands.Enqueue(action);
        if (!inProcess)
        {
          inProcess = true;
          disposeEvent.Reset();
          ThreadPool.QueueUserWorkItem(Process);
        }
      }
    }
 
    private void Process(object o)
    {
      while (true)
      {
        Action action;
 
        lock (syncObject)
        {
          if (commands.Count == 0)
          {
            inProcess = false;
            disposeEvent.Set();
            return;
          }
 
          action = commands.Dequeue();
        }
 
        try
        {
          action();
        }
        catch (Exception e)
        {
          OnError(e);
        }
      }
    }
 
    public void Dispose()
    {
      if (disposed)
        return;
 
      disposed = true;
 
      // Можно не очищать, если нужно дожидатся пока все задачи будут выполнены
      lock (syncObject) 
        commands.Clear();
 
      if (!disposeEvent.WaitOne(disposeEventTimeout))
        OnError(new Exception("RequestQueue.Dispose() timeout"));
    }
 
    protected abstract void OnError(Exception e);
  }

private static BufferBlock<int> m_data = …;
…
private static async Task ConsumerAsync()
{
    while(true)
    {
        int nextItem = await m_data.ReceiveAsync();
        ProcessNextItem(nextItem);
    }
}
…
private static void Produce(int data)
{
    m_data.Post(data);
}