Як запустити простий біт коду в новій темі?

У мене є трохи коду, який мені потрібно запустити в іншому потоці, ніж GUI, оскільки він в даний час призводить до застигання форми під час роботи коду (10 секунд або близько того).

Припустимо, я ніколи раніше не створював нової теми; який простий / основний приклад того, як це зробити в C # та за допомогою .NET Framework 2.0 або новіших версій?

Хороше місце для початку читання - Джо Альбахарі .

Якщо ви хочете створити власну нитку, це так просто, як це виходить:

using System.Threading;
new Thread(() => 
{
    Thread.CurrentThread.IsBackground = true; 
    /* run your code here */ 
    Console.WriteLine("Hello, world"); 
}).Start();

BackgroundWorker здається, найкращий вибір для вас.

Ось мій мінімальний приклад. Після натискання на кнопку фоновий працівник почне працювати у фоновому потоці, а також одночасно повідомить про його хід. Він також звітуватиме після завершення роботи.

using System.ComponentModel;
...
    private void button1_Click(object sender, EventArgs e)
    {
        BackgroundWorker bw = new BackgroundWorker();

        // this allows our worker to report progress during work
        bw.WorkerReportsProgress = true;

        // what to do in the background thread
        bw.DoWork += new DoWorkEventHandler(
        delegate(object o, DoWorkEventArgs args)
        {
            BackgroundWorker b = o as BackgroundWorker;

            // do some simple processing for 10 seconds
            for (int i = 1; i <= 10; i++)
            {
                // report the progress in percent
                b.ReportProgress(i * 10);
                Thread.Sleep(1000);
            }

        });

        // what to do when progress changed (update the progress bar for example)
        bw.ProgressChanged += new ProgressChangedEventHandler(
        delegate(object o, ProgressChangedEventArgs args)
        {
            label1.Text = string.Format("{0}% Completed", args.ProgressPercentage);
        });

        // what to do when worker completes its task (notify the user)
        bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(
        delegate(object o, RunWorkerCompletedEventArgs args)
        {
            label1.Text = "Finished!";
        });

        bw.RunWorkerAsync();
    }

Примітка:

• Я вкладаю все в один метод, використовуючи анонімний метод C # для простоти, але ви завжди можете витягнути їх на різні методи.
• Оновити GUI всередині ProgressChangedабо RunWorkerCompletedобробників можна безпечно . Однак оновлення графічного інтерфейсу від DoWork спричинить InvalidOperationException.

ThreadPool.QueueUserWorkItem досить ідеально підходить для чого - то просто. Єдине застереження - це доступ до елемента керування з іншого потоку.

System.Threading.ThreadPool.QueueUserWorkItem(delegate {
    DoSomethingThatDoesntInvolveAControl();
}, null);

Швидкий і брудний, але він буде працювати:

Використання вгорі:

using System.Threading;

простий код:

static void Main( string[] args )
{
    Thread t = new Thread( NewThread );
    t.Start();
}

static void NewThread()
{
    //code goes here
}

Я просто перекинув це на нову консольну програму для прикладу

Ось ще один варіант:

Task.Run(()=>{
//Here is a new thread
});

Спробуйте використовувати клас BackgroundWorker . Ви даєте йому делегатів, на що працювати, і отримувати повідомлення про те, коли робота закінчена. На прикладі сторінки MSDN є приклад, на який я посилався.

Якщо ви хочете отримати значення:

var someValue;

Thread thread = new Thread(delegate()
            {                 
                //Do somthing and set your value
                someValue = "Hello World";
            });

thread.Start();

while (thread.IsAlive)
  Application.DoEvents();

Покладіть цей код у функцію (код, який не може бути виконаний у тому ж потоці, що і GUI), а для запуску виконання цього коду поставте наступне.

Thread myThread= new Thread(nameOfFunction);

workerThread.Start();

Виклик функції запуску на об'єкт потоку спричинить виконання вашого виклику функції в новому потоці.

Ось як можна використовувати потоки з progressBar, його лише для підкреслення того, як працюють потоки, у формі є три кнопки progressBar та 4 кнопки:

 public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }
    Thread t, t2, t3;
    private void Form1_Load(object sender, EventArgs e)
    {

        CheckForIllegalCrossThreadCalls = false;

         t = new Thread(birinicBar); //evry thread workes with a new progressBar


         t2 = new Thread(ikinciBar);


         t3 = new Thread(ucuncuBar);

    }

    public void birinicBar() //to make progressBar work
    {
        for (int i = 0; i < 100; i++) {
            progressBar1.Value++;
            Thread.Sleep(100); // this progressBar gonna work faster
        }
    }

    public void ikinciBar()
    {
        for (int i = 0; i < 100; i++)
        {
            progressBar2.Value++;
            Thread.Sleep(200);
        }


    }

    public void ucuncuBar()
    {
        for (int i = 0; i < 100; i++)
        {
            progressBar3.Value++;
            Thread.Sleep(300);
        }
    }

    private void button1_Click(object sender, EventArgs e) //that button to start the threads
    {
        t.Start();
        t2.Start(); t3.Start();

    }

    private void button4_Click(object sender, EventArgs e)//that button to stup the threads with the progressBar
    {
        t.Suspend();
        t2.Suspend();
        t3.Suspend();
    }

    private void button2_Click(object sender, EventArgs e)// that is for contuniue after stuping
    {
        t.Resume();
        t2.Resume();
        t3.Resume();
    }

    private void button3_Click(object sender, EventArgs e) // finally with that button you can remove all of the threads
    {
        t.Abort();
        t2.Abort();
        t3.Abort();
    }
}

// following declaration of delegate ,,,
public delegate long GetEnergyUsageDelegate(DateTime lastRunTime, 
                                            DateTime procDateTime);

// following inside of some client method
GetEnergyUsageDelegate nrgDel = GetEnergyUsage;
IAsyncResult aR = nrgDel.BeginInvoke(lastRunTime, procDT, null, null);
while (!aR.IsCompleted) Thread.Sleep(500);
int usageCnt = nrgDel.EndInvoke(aR);

Чарльз ваш код (вище) невірний. Чекати завершення не потрібно. EndInvoke заблокує, поки не надійде сигнал WaitHandle.

Якщо ви хочете заблокувати до завершення, вам просто потрібно

nrgDel.EndInvoke(nrgDel.BeginInvoke(lastRuntime,procDT,null,null));

або альтернативно

ar.AsyncWaitHandle.WaitOne();

Але який сенс видавати будь-які дзвінки, якщо ви блокуєте? Ви можете просто використовувати синхронний дзвінок. Краще зробити ставку не заблокувати та пропустити в лямбда на прибирання:

nrgDel.BeginInvoke(lastRuntime,procDT,(ar)=> {ar.EndInvoke(ar);},null);

Варто пам’ятати, що ви повинні зателефонувати в EndInvoke. Багато людей забувають про це і в кінцевому підсумку витікають WaitHandle, оскільки більшість асинхронних програм випускає чеканку в EndInvoke.

Якщо ви збираєтесь використовувати об'єкт "Thread raw", тоді потрібно встановити IsBackground на "true" як мінімум, а також слід встановити модель Threading Apartment (можливо, STA).

public static void DoWork()
{
    // do some work
}

public static void StartWorker()
{
    Thread worker = new Thread(DoWork);
    worker.IsBackground = true;
    worker.SetApartmentState(System.Threading.ApartmentState.STA);
    worker.Start()
}

Я рекомендую клас BackgroundWorker, якщо вам потрібна взаємодія з інтерфейсом користувача.

інший варіант, який використовує делегатів та нитку басейну ...

припускаючи, що "GetEnergyUsage" - це метод, який приймає DateTime та інший DateTime як вхідні аргументи та повертає Int ...

// following declaration of delegate ,,,
public delegate long GetEnergyUsageDelegate(DateTime lastRunTime, 
                                            DateTime procDateTime);

// following inside of some client method 
GetEnergyUsageDelegate nrgDel = GetEnergyUsage;                     
IAsyncResult aR = nrgDel.BeginInvoke(lastRunTime, procDT, null, null);
while (!aR.IsCompleted) Thread.Sleep(500);
int usageCnt = nrgDel.EndInvoke(aR);

Існує багато способів запуску окремих потоків у .Net, кожен має різну поведінку. Чи потрібно продовжувати запускати потік після завершення GUI? Чи потрібно передавати інформацію між потоком та графічним інтерфейсом? Чи потрібно потоці оновлювати графічний інтерфейс? Чи повинен нитка виконати одне завдання, а потім вийти з роботи, чи продовжувати працювати? Відповіді на ці запитання підкажуть, який метод використовувати.

На веб-сайті Code Project є хороша стаття про метод асинхронізації, яка описує різні методи та надає зразок коду.

Зверніть увагу , що ця стаття була написана до асинхронного / ОЧІКУВАННЯ малюнка і Task Parallel Library був введений в .NET.

Як: Використовуйте фонову нитку для пошуку файлів

Ви повинні бути дуже обережними з доступом з інших потоків до специфічних GUI (це звичайно для багатьох наборів інструментів GUI). Якщо ви хочете щось оновити в графічному інтерфейсі з обробки потоку, перевірте цю відповідь, що я вважаю корисним для WinForms. Для WPF дивіться це (він показує, як доторкнутися до компонента в методі UpdateProgress (), щоб він працював з інших потоків, але насправді мені не подобається, що це не робиться CheckAccess()перед тим, як робити BeginInvokeчерез Dispathcer, див. і шукайте в ньому CheckAccess)

Шукав .NET специфічну книгу з нарізання різьби і знайшов цю (безкоштовно завантажувану). Детальніше про це див. На веб-сайті http://www.albahari.com/threading/ .

Я вірю, що ви знайдете те, що вам потрібно, щоб запустити виконання як новий потік на перших 20 сторінках, і в ньому є ще багато (не впевнений, у конкретних фрагментах графічного інтерфейсу, я маю на увазі строго специфічну для нитки). Буду радий почути, що громада думає про цей твір, бо я читаю цей. Поки що для мене це виглядало досить акуратно (для показу .NET конкретних методів та типів для нарізки різьби). Також він охоплює .NET 2.0 (а не стародавній 1.1), що я дуже ціную.

Я рекомендую переглянути бібліотеку Джефф Ріхтер Power Power Threading та конкретно IAsyncEnumerator. Погляньте на відео в блозі Чарлі Калверта, де Ріхтер переглядає його для гарного огляду.

Не відкладайте ім’я, оскільки це полегшує кодування завдань асинхронного програмування.