Приносим извинения за такой длинный ответ. Но я подумал, что стоит объяснить, что именно происходит.

Ага! Думаю, я понял это. Наиболее общий способ вызова делегата в конкретном потоке действительно кажется классом SynchronizationContext.

Во-первых, платформа .NET не предоставляет средства по умолчанию для простой «отправки» делегата в любой поток, чтобы он немедленно выполнялся там. Очевидно, это не может сработать, потому что это означало бы «прерывание» любой работы, которую поток выполнял бы в то время. Следовательно, целевой поток сам решает, как и когда он будет «получать» делегатов; то есть эта функциональность должна предоставляться программистом.

Таким образом, целевой поток нуждается в каком-то способе «приема» делегатов. Это можно сделать разными способами. Один простой механизм состоит в том, чтобы поток всегда возвращался в некоторый цикл (назовем его «цикл сообщений»), где он будет смотреть на очередь. Он сработает все, что находится в очереди. Windows изначально работает так, когда дело доходит до вещей, связанных с пользовательским интерфейсом.

Далее я продемонстрирую, как реализовать очередь сообщений и SynchronizationContext для нее, а также поток с циклом сообщений. Наконец, я продемонстрирую, как вызвать делегата в этом потоке.

Пример:

Шаг 1. Давайте сначала создадим SynchronizationContext класс, который будет использоваться вместе с очередью сообщений целевого потока:

class QueueSyncContext : SynchronizationContext
{
    private readonly ConcurrentQueue<SendOrPostCallback> queue;

    public QueueSyncContext(ConcurrentQueue<SendOrPostCallback> queue)
    {
        this.queue = queue;
    }

    public override void Post(SendOrPostCallback d, object state)
    {
        queue.Enqueue(d);
    }

    // implementation for Send() omitted in this example for simplicity's sake.
}

По сути, это не более чем добавление всех делегатов, переданных через Post, в очередь, предоставленную пользователем. (Post - это метод для асинхронных вызовов. Send предназначен для синхронных вызовов. Я пока опускаю последний.)

Шаг 2. Теперь напишем код для потока Z, который ожидает прибытия делегатов d:

SynchronizationContext syncContextForThreadZ = null;

void MainMethodOfThreadZ()
{
    // this will be used as the thread's message queue:
    var queue = new ConcurrentQueue<PostOrCallDelegate>();

    // set up a synchronization context for our message processing:
    syncContextForThreadZ = new QueueSyncContext(queue);
    SynchronizationContext.SetSynchronizationContext(syncContextForThreadZ);

    // here's the message loop (not efficient, this is for demo purposes only:)
    while (true)
    {
        PostOrCallDelegate d = null;
        if (queue.TryDequeue(out d))
        {
            d.Invoke(null);
        }
    }
}

Шаг 3. Поток Z нужно где-то запускать:

new Thread(new ThreadStart(MainMethodOfThreadZ)).Start();

Шаг 4. Наконец, вернемся к другой теме A, мы хотим отправить делегата в тему Z:

void SomeMethodOnThreadA()
{
    // thread Z must be up and running before we can send delegates to it:
    while (syncContextForThreadZ == null) ;

    syncContextForThreadZ.Post(_ =>
        {
            Console.WriteLine("This will run on thread Z!");
        },
        null);
}

Приятно то, что SynchronizationContext работает независимо от того, работаете ли вы в приложении Windows Forms, в приложении WPF или в многопоточном консольном приложении, созданном вами. И Winforms, и WPF предоставляют и устанавливают подходящие SynchronizationContexts для своего основного потока / потока пользовательского интерфейса.

Общая процедура вызова делегата в конкретном потоке следующая:

• Вы должны захватить (Z) SynchronizationContext целевого потока, чтобы вы могли Send (синхронно) или Post (асинхронно) делегатом этому потоку. Для этого нужно сохранить контекст синхронизации, возвращаемый SynchronizationContext.Current, пока вы находитесь в целевом потоке Z. (Этот контекст синхронизации должен быть ранее зарегистрирован в / потоком Z.) Затем сохраните эту ссылку где-нибудь, где она доступна для потока A.

• Находясь в потоке A, вы можете использовать захваченный контекст синхронизации для отправки или публикации любого делегата в потоке Z: zSyncContext.Post(_ => { ... }, null);

Если вы хотите поддержать вызов делегата в потоке, который иначе не имеет цикла сообщений, вам, по сути, необходимо реализовать свой собственный.

В цикле сообщений нет ничего особенного волшебства: это как потребитель в обычном шаблоне производитель / потребитель. Он хранит очередь дел, которые нужно сделать (обычно события, на которые нужно реагировать), и проходит через очередь, действуя соответствующим образом. Когда больше нечего делать, он ждет, пока что-то не будет помещено в очередь.

Другими словами: вы можете представить поток с циклом сообщений как однопоточный пул потоков.

Вы можете достаточно легко реализовать это самостоятельно, в том числе в консольном приложении. Просто помните, что если поток зацикливается вокруг очереди работ, он не может делать что-то еще - тогда как обычно основной поток выполнения в консольном приложении предназначен для выполнения последовательности задач, а затем завершения.

Если вы используете .NET 4, очень легко реализовать очередь производителя / потребителя, используя BlockingCollection класс.