Simple dispatcher implementation I need a simple dispatcher implementation(invoke methods on one thread from many threads) 
once you dispatch method curent thread should wait for results, so I'm thinking about something like this:

public class Dispatcher
{
    private readonly BlockingCollection&lt;Tuple&lt;Delegate, object[]&gt;&gt; runQueue = new BlockingCollection&lt;Tuple&lt;Delegate, object[]&gt;&gt;();
    private readonly BlockingCollection&lt;object&gt; resultQueue = new BlockingCollection&lt;object&gt;();
    private readonly CancellationTokenSource source = new CancellationTokenSource();
    private readonly Task task;
    public Dispatcher()
    {
        Task.Run(() =&gt;
        {
            using (source)
            using (runQueue)
            using (resultQueue)
            {
                Debug.WriteLine("Dispatcher started with thread {0}", Thread.CurrentThread.ManagedThreadId);
                while (!source.IsCancellationRequested)
                {
                    var run = runQueue.Take(source.Token);
                    resultQueue.Add(run.Item1.DynamicInvoke(run.Item2));
                }
                Debug.WriteLine("Dispatcher ended");
            }
        });
    }

    public void Stop()
    {
        source.Cancel();
    }

    [MethodImpl(MethodImplOptions.Synchronized)]
    public object Invoke(Delegate @delegate, params object[] @params)
    {
        runQueue.Add(new Tuple&lt;Delegate, object[]&gt;(@delegate, @params));
        return resultQueue.Take(source.Token);
    }
}


I had test it with such code and it seems too work well ... 

class Program
{
    static void Main(string[] args)
    {
        Func&lt;int, int, int&gt; func = (sleep, i) =&gt;
        {
            CC.WriteLine(i, "\tTask {0} will sleep for {1}, thread {2}", i, sleep, Thread.CurrentThread.ManagedThreadId);
            Thread.Sleep(sleep);
            CC.WriteLine(i, "\tTask {0} woke up", i, sleep);
            return i; //return task number
        };
        var rnd = new Random();
        var disp = new Dispatcher();
        {
            var tasks = Enumerable.Range(0, 10).Select(i =&gt;
                            Task.Run(() =&gt;
                            {
                                CC.WriteLine(i, "Task {0} started, thread {1}", i, Thread.CurrentThread.ManagedThreadId);
                                CC.WriteLine(i, "Task {0} ended with {1}", i, disp.Invoke(func, rnd.Next(3, 15) * 100, i));
                            })).ToArray();
            Task.WaitAll(tasks);
            disp.Stop();
        }

        Console.ReadKey();

    }
    static class CC
    {
        public static readonly List&lt;ConsoleColor&gt; COLORS = Enum.GetValues(typeof(ConsoleColor)).Cast&lt;ConsoleColor&gt;().ToList();
        static CC()
        {
            COLORS.RemoveAt(0);
            COLORS.RemoveAt(0);
        }
        public static void WriteLine(int colorIndex, string format, params object[] args)
        {
            lock (COLORS)
            {
                Console.ForegroundColor = COLORS[colorIndex];
                Console.WriteLine(format, args);
            }
        }
    }
}


Is a BlockingCollection a good choice? 
Or maybe it can be done with something simpler? (SlimSemaphore)?
Because the task within the Dispatcher is a long running task, you should use the option TaskCreationOptions.LongRunning. Otherwise the operation blocks a thread-pool thread that is usually used for short operations. Alternatively you could also use a Thread.
Instead of using the blocking collection for returning the result, you could use a TaskCompletionSource. That would change the return value of the method Invoke to Task&lt;T&gt;. Therfore the calling code could use the async/await-pattern.
Consider to throw an exception if the Dispatcher was stopped and Invoke is called. Otherwise the call blocks forever, right?