.NET: как получить доступ к данным основного потока сигнала фонового потока?

Вот пример кода для класса System.ComponentModel.BackgroundWorker.

    private static BackgroundWorker worker = new BackgroundWorker();
    static void Main(string[] args)
    {
        worker.DoWork += worker_DoWork;
        worker.RunWorkerCompleted += worker_RunWorkerCompleted;
        worker.ProgressChanged += worker_ProgressChanged;
        worker.WorkerReportsProgress = true;

        Console.WriteLine("Starting application.");
        worker.RunWorkerAsync();

        Console.ReadKey();
    }

    static void worker_ProgressChanged(object sender, ProgressChangedEventArgs e)
    {
        Console.WriteLine("Progress.");
    }

    static void worker_DoWork(object sender, DoWorkEventArgs e)
    {
        Console.WriteLine("Starting doing some work now.");

        for (int i = 0; i < 5; i++)
        {
            Thread.Sleep(1000);
            worker.ReportProgress(i);
        }
    }

    static void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
    {
        Console.WriteLine("Done now.");
    }

Я объединяю здесь несколько ответов.

В идеальном случае используется флаг потокобезопасности, например AutoResetEvent. Вам не нужно блокировать на неопределенный срок, когда вы вызываете WaitOne(), на самом деле у него есть перегрузка, которая позволяет вам указать тайм-аут. Эта перегрузка возвращает false, если флаг не был установлен в течение интервала.

Queue - более идеальная структура для отношений производителя и потребителя, но вы можете имитировать ее, если ваши требования вынуждают вас использовать List. Основное отличие состоит в том, что вам нужно будет гарантировать, что ваш потребитель заблокирует доступ к коллекции во время извлечения элементов; Самый безопасный вариант - это, вероятно, использовать метод CopyTo для копирования всех элементов в массив, а затем снять блокировку. Конечно, убедитесь, что ваш производитель не будет пытаться обновить List, пока блокировка удерживается.

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

using System;
using System.Collections.Generic;
using System.Threading;

namespace ConsoleApplication1
{
    class Program
    {
        private static object LockObject = new Object();

        private static AutoResetEvent _flag;
        private static Queue<int> _list;

        static void Main(string[] args)
        {
            _list = new Queue<int>();
            _flag = new AutoResetEvent(false);

            ThreadPool.QueueUserWorkItem(ProducerThread);

            int itemCount = 0;

            while (itemCount < 10)
            {
                if (_flag.WaitOne(0))
                {
                    // there was an item
                    lock (LockObject)
                    {
                        Console.WriteLine("Items in queue:");
                        while (_list.Count > 0)
                        {
                            Console.WriteLine("Found item {0}.", _list.Dequeue());
                            itemCount++;
                        }
                    }
                }
                else
                {
                    Console.WriteLine("No items in queue.");
                    Thread.Sleep(125);
                }
            }
        }

        private static void ProducerThread(object state)
        {
            Random rng = new Random();

            Thread.Sleep(250);

            for (int i = 0; i < 10; i++)
            {
                lock (LockObject)
                {
                    _list.Enqueue(rng.Next(0, 100));
                    _flag.Set();
                    Thread.Sleep(rng.Next(0, 250));
                }
            }
        }
    }
}

Если вы вообще не хотите блокировать производителя, это немного сложнее. В этом случае я бы предложил сделать производителя его собственным классом как с частным, так и с общедоступным буфером, а также с общедоступным AutoResetEvent. По умолчанию производитель сохраняет элементы в частном буфере, а затем пытается записать их в общий буфер. Когда потребитель работает с общедоступным буфером, он сбрасывает флаг на объекте-производителе. Прежде чем производитель попытается переместить элементы из частного буфера в общий буфер, он проверяет этот флаг и копирует элементы только тогда, когда потребитель не работает с ним.

Если вы используете backgroundworker для запуска второго потока и используете событие ProgressChanged, чтобы уведомить другой поток о готовности данных. Доступны и другие мероприятия. Эта статья MSDN должна помочь вам начать работу.

Есть много способов сделать это, в зависимости от того, что именно вы хотите сделать. Возможно, вам нужна очередь производителя / потребителя. Для получения более подробной информации о потоках см. Главу о Threading (доступна в Интернете) на веб-сайте отличная книга C # 3.0 в двух словах.

Вы можете использовать AutoResetEvent (или ManualResetEvent). Если вы используете AutoResetEvent.WaitOne (0, false), он не будет блокироваться. Например:

AutoResetEvent ev = new AutoResetEvent(false);
...
if(ev.WaitOne(0, false)) {
  // event happened
}
else {
 // do other stuff
}

В этом случае ответом является класс BackgroundWorker. Это единственная потоковая конструкция, которая может асинхронно отправлять сообщения в поток, который создал объект BackgroundWorker. Внутри BackgroundWorker используется класс AsyncOperation, вызывая метод asyncOperation.Post().

this.asyncOperation = AsyncOperationManager.CreateOperation(null);
this.asyncOperation.Post(delegateMethod, arg);

Несколько других классов в платформе .NET также используют AsyncOperation:

• Справочная информация
• SoundPlayer.LoadAsync ()
• SmtpClient.SendAsync ()
• Ping.SendAsync ()
• WebClient.DownloadDataAsync ()
• WebClient.DownloadFile ()
• WebClient.DownloadFileAsync ()
• Веб-клиент ...
• PictureBox.LoadAsync ()

Если ваш «основной» поток - это поток сообщений Windows (GUI), то вы можете опросить с помощью Forms.Timer - настройте интервал таймера в соответствии с тем, насколько быстро вам нужно, чтобы поток GUI «заметил» данные из рабочего потока. .

Не забудьте синхронизировать доступ к общему List<>, если вы собираетесь использовать foreach, чтобы избежать CollectionModified исключений.

Я использую этот метод для всех обновлений графического интерфейса на основе рыночных данных в торговом приложении в реальном времени, и он работает очень хорошо.