单个Windows Form C＃中的多个BackGroundWorker组件

Question

Before discussing my problem, I want to know you about my stage.I am very new to C# programming. It is the first time I am working on it. So my knowledge in C# is very minimum.

I am developing my application using Windows Forms in C#. At some instant I was supposed to run 5 operations simultaneously . So that I tried the BackGroundWorker Component in the ToolBox of C#.

But using that, I could process only one of my operations among 5. I tried using 5 BackGroundWorker Components from the ToolBox and defined the DoWork functions seperately.

But when I called the RunWorkerAsync() function it threw an error saying " backgroundworker is currently busy and cannot run multiple tasks concurrently ".

I don't whether I can use multiple BackGroundWorker in my program.Creating array didn't help me. Because I have a infinite loop to be run inside the DoWork functions of the BackGroundWorker components. If there is any other way to run 5 operations at the same time, Please help me get an idea about that. Thanks in advance.

Here is my code:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Threading;
using System.Runtime.InteropServices;


namespace myapp5
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            bw.WorkerSupportsCancellation = true;
            bw.WorkerReportsProgress = true;

            bw.DoWork += new DoWorkEventHandler(bw_DoWork);

            bw1.WorkerSupportsCancellation = true;
            bw1.WorkerReportsProgress = true;

            bw1.DoWork += new DoWorkEventHandler(bw1_DoWork);
        }

        BackgroundWorker bw = new BackgroundWorker();
        BackgroundWorker bw1 = new BackgroundWorker();
        private void bw_DoWork(object sender, DoWorkEventArgs e)
        {
            BackgroundWorker worker = sender as BackgroundWorker;

            if ((worker.CancellationPending == true))
            {
                e.Cancel = true;
            }
            else
            {
                try
                {
                    videostream();
                }
                catch (Exception exc)
                {
                    MessageBox.Show(exc.Message);
                }
            }
        }
        private void bw1_DoWork(object sender, DoWorkEventArgs e)
        {
            BackgroundWorker worker = sender as BackgroundWorker;

            if ((worker.CancellationPending == true))
            {
                e.Cancel = true;
            }
            else
            {
                try
                {
                    videostream();
                }
                catch (Exception exc)
                {
                    MessageBox.Show(exc.Message);
                }
            }
        }
        private void button2_Click(object sender, EventArgs e)
        {

            if (bw.IsBusy != true)
            {
                bw.RunWorkerAsync();
            }
            else
            {
                MessageBox.Show("Background Worker is busy");
            }
        }
        private void button3_Click(object sender, EventArgs e)
        {
            if (bw.WorkerSupportsCancellation == true)
            {
                bw.CancelAsync();
                bw.Dispose();
                MessageBox.Show("Background Closed");
            }
        }

        private void button4_Click(object sender, EventArgs e)
        {
            if (bw1.IsBusy != true)
            {
                bw1.RunWorkerAsync();
            }
            else
            {
                MessageBox.Show("Background Worker is busy");
            }
        }
        private void button5_Click(object sender, EventArgs e)
        {
            if (bw1.WorkerSupportsCancellation == true)
            {
                bw1.CancelAsync();
                bw1.Dispose();
                MessageBox.Show("Background Closed");
            }
        }
    }
}

Answer 1

If you want to perform 5 different function parallel than you need to 5 backgroundworker thread for that. One Backgroupwork thread is not sufficient for running 5 different function parallel.

You can also you TPL(taksparallel) library for this instead of backgroundworker.

Answer 2

You should try thread for nominal use.

private object threadUnsafeObject;
    private object locker = new object();

    private void RunMulitpleThread()
    {
        object pass_your_parameter_here = "";
        for (int iCount = 0; iCount < 5; iCount++)
        {
            System.Threading.Thread thread = new System.Threading.Thread(DoWork);
            thread.Start(pass_your_parameter_here);

        }
    }

    private void DoWork(object parameters)
    {
        lock (locker)
        {
            threadUnsafeObject = parameters;
        }
    }

Answer 3

I think that your program have logical error so the same BackgroundWorker instance is used five times for calling RunWorkerAsync(). Review the code for this.

UPD

Your DoWork handler must look like this:

private void bw_DoWork(object sender, DoWorkEventArgs e)
{
    BackgroundWorker worker = sender as BackgroundWorker;

    while (true)
    {
        if ((worker.CancellationPending == true))
        {
            e.Cancel = true;
            break;
        }
        else
        {
            // perform work partially with short time!
            // and break the while loop at the end
        }
    }
}

UPD-2

Don't use Dispose() for workers.

Answer 4

If you're using .net 4.0 or above, you should use Tasks. This is the direction where the .NET framework is moving. I've set up two fiddles for you to check out. If you're using .NET 4.0 : https://dotnetfiddle.net/GUxD2j . If you're using .NET 4.5: https://dotnetfiddle.net/NirDuU . This sample shows the use of the new await/ async pattern introduced in the .NET framework