If you're not in a UI context, why do you want the callback to occur on the
calling thread?

David

What you need is not a queue but a "message thread" class, waiting for
message and dispatching them.
I don't think it needs to be an API class as it is:
1. simple enough to program
2. really depends on the specific of the application

about 2, I would say that myControl.BeginInvoke(aDelegate) is a GUI specific
mechanism, which work well with the GUI event thread.

But how is it to work with any other thread?
I mean, common, a thread is just a unit of code execution, it doesn't have
concept such as 'event' or 'message'

Anyway here is a pseudo code MessageThread implementation for you (from the
top of my head).

class MessageThread<T>
{
   Thread runner;
   LinkedList<MsgInfo> list = new LinkedList<MsgInfo>();
   ManualResetEvent waiter;
   class MsgInfo
   {
       public MsgInfo(EventHandler<T> eh, object sender, EventArgs<T> e)
       {
           this.eh = eh;
           this.sender = sender;
           this.args = e;
       }
       public EventHandler<T> eh;
       public object sender;
       public EventArgs<T> arg;
   }

   public MessageThread()
   {

       runner = new Thread(MessageLoop);
       waiter = new ManualResetEvent(false);
   }

   public void Run()
   {
       runner.Run();
   }
   void MessageLoop()
   {
       while(running)
       {
           waiter.Wait();
           MsgInfo msg = null;
           lock(list)
           {
               if(list.Count == 0 || !running)
                   waiter.Reset();
               else
                   msg = list.RemoveHead();
           }
           if(msg != null)
               msg.eh(msg.sender, msg.args);
       }
   }

   public void Dispatch(EventHandler<T> eh, object sender, EventArgs<T> e)
   {
       lock(list)
       {
           list.AddTail(new MsgInfo(eh, sender, e));
           waiter.Set();
       }
   }
}

Dan,

You could use the same approach that Microsoft used when designing the
System.Timers.Timer class.  That class has a property called
SynchronizingObject that accepts an ISynchronizeInvoke interface.  When
the timer has a synchronizing object set it invokes the callback on the
thread hosting that object, otherwise it invokes the callback from the
thread pool.  Forms and Controls implement ISynchronizingInvoke so the
pattern works well for what you're after.

Brian